ext
stringclasses 9
values | sha
stringlengths 40
40
| content
stringlengths 3
1.04M
|
|---|---|---|
py | 7dfee9945e0ac8148740643fc3ec90d75f8ce2df | # -*- coding: utf-8 -*-
from tests.test_experiments import IS_ACTIVE
from unittest import TestCase
from fastapi.testclient import TestClient
from projects.api.main import app
from projects.controllers.utils import uuid_alpha
from projects.database import engine
TEST_CLIENT = TestClient(app)
PROJECT_ID = str(uuid_alpha())
PROJECT_ID_2 = str(uuid_alpha())
NAME = "foo"
NAME_2 = "foo 2"
NAME_3 = "foo 3"
DESCRIPTION = "Description"
EXPERIMENT_ID = str(uuid_alpha())
EXPERIMENT_ID_2 = str(uuid_alpha())
EXPERIMENT_NAME = "Experimento 1"
DEPLOYMENT_ID = str(uuid_alpha())
STATUS = "Pending"
URL = None
POSITION = 0
IS_ACTIVE = True
CREATED_AT = "2000-01-01 00:00:00"
CREATED_AT_ISO = "2000-01-01T00:00:00"
UPDATED_AT = "2000-01-01 00:00:00"
UPDATED_AT_ISO = "2000-01-01T00:00:00"
class TestProjects(TestCase):
def setUp(self):
self.maxDiff = None
conn = engine.connect()
text = (
f"INSERT INTO projects (uuid, name, description, created_at, updated_at) "
f"VALUES (%s, %s, %s, %s, %s)"
)
conn.execute(text, (PROJECT_ID, NAME, DESCRIPTION, CREATED_AT, UPDATED_AT))
text = (
f"INSERT INTO projects (uuid, name, description, created_at, updated_at) "
f"VALUES (%s, %s, %s, %s, %s)"
)
conn.execute(text, (PROJECT_ID_2, NAME_2, DESCRIPTION, CREATED_AT, UPDATED_AT))
text = (
f"INSERT INTO experiments (uuid, name, project_id, position, is_active, created_at, updated_at) "
f"VALUES (%s, %s, %s, %s, %s, %s, %s)"
)
conn.execute(text, (EXPERIMENT_ID, NAME, PROJECT_ID, POSITION, IS_ACTIVE, CREATED_AT, UPDATED_AT))
text = (
f"INSERT INTO experiments (uuid, name, project_id, position, is_active, created_at, updated_at) "
f"VALUES (%s, %s, %s, %s, %s, %s, %s)"
)
conn.execute(text, (EXPERIMENT_ID_2, NAME, PROJECT_ID_2, POSITION, IS_ACTIVE, CREATED_AT, UPDATED_AT))
text = (
f"INSERT INTO deployments (uuid, name, project_id, experiment_id, position, is_active, status, url, created_at, updated_at) "
f"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
)
conn.execute(text, (DEPLOYMENT_ID, NAME, PROJECT_ID_2, EXPERIMENT_ID_2, POSITION, IS_ACTIVE, STATUS, URL, CREATED_AT, UPDATED_AT))
conn.close()
def tearDown(self):
conn = engine.connect()
text = f"DELETE FROM deployments WHERE project_id = '{PROJECT_ID_2}'"
conn.execute(text)
text = f"DELETE FROM experiments WHERE project_id = '{PROJECT_ID}'"
conn.execute(text)
text = f"DELETE FROM experiments WHERE project_id = '{PROJECT_ID_2}'"
conn.execute(text)
text = f"DELETE e.* FROM experiments e INNER JOIN projects p ON e.project_id = p.uuid WHERE p.name = '{NAME_3}'"
conn.execute(text)
text = f"DELETE FROM projects WHERE uuid = '{PROJECT_ID}'"
conn.execute(text)
text = f"DELETE FROM projects WHERE uuid = '{PROJECT_ID_2}'"
conn.execute(text)
text = f"DELETE FROM projects WHERE name = '{NAME_3}'"
conn.execute(text)
conn.close()
def test_list_projects(self):
rv = TEST_CLIENT.get("/projects")
result = rv.json()
self.assertIsInstance(result['projects'], list)
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.get("/projects?order=uuid asc")
result = rv.json()
self.assertIsInstance(result["projects"], list)
self.assertIsInstance(result["total"], int)
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.get("/projects?page=1")
result = rv.json()
self.assertIsInstance(result["projects"], list)
self.assertIsInstance(result["total"], int)
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.get(f"/projects?name={NAME}&page=1&order=uuid asc")
result = rv.json()
self.assertIsInstance(result["projects"], list)
self.assertIsInstance(result["total"], int)
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.get(f"/projects?name={NAME}&page=1&page_size=10&order=name desc")
result = rv.json()
self.assertIsInstance(result["projects"], list)
self.assertIsInstance(result["total"], int)
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.get("/projects?order=name desc")
result = rv.json()
self.assertIsInstance(result["projects"], list)
self.assertIsInstance(result["total"], int)
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.get("/projects?order=name unk")
result = rv.json()
expected = {"message": "Invalid order argument"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 400)
rv = TEST_CLIENT.get("/projects?order=name")
result = rv.json()
expected = {"message": "Invalid order argument"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 400)
def test_create_project(self):
rv = TEST_CLIENT.post("/projects", json={})
self.assertEqual(rv.status_code, 422)
rv = TEST_CLIENT.post("/projects", json={
"name": NAME
})
result = rv.json()
expected = {"message": "a project with that name already exists"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 400)
rv = TEST_CLIENT.post("/projects", json={
"name": NAME_3,
"description": DESCRIPTION
})
result = rv.json()
result_experiments = result.pop("experiments")
expected = {
"name": NAME_3,
"description": DESCRIPTION,
"hasDeployment": False,
"hasExperiment": True,
"hasPreDeployment": False,
"deployments": []
}
# uuid, created_at, updated_at are machine-generated
# we assert they exist, but we don't assert their values
machine_generated = ["uuid", "createdAt", "updatedAt"]
for attr in machine_generated:
self.assertIn(attr, result)
del result[attr]
self.assertDictEqual(expected, result)
expected = {
"name": EXPERIMENT_NAME,
"position": POSITION,
"isActive": IS_ACTIVE,
"operators": [],
}
self.assertEqual(len(result_experiments), 1)
machine_generated = ["uuid", "projectId", "createdAt", "updatedAt"]
for attr in machine_generated:
self.assertIn(attr, result_experiments[0])
del result_experiments[0][attr]
self.assertDictEqual(expected, result_experiments[0])
def test_get_project(self):
rv = TEST_CLIENT.get("/projects/foo")
result = rv.json()
expected = {"message": "The specified project does not exist"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 404)
rv = TEST_CLIENT.get(f"/projects/{PROJECT_ID_2}")
result = rv.json()
result_experiments = result.pop("experiments")
result_deployments = result.pop("deployments")
expected = {
"uuid": PROJECT_ID_2,
"name": NAME_2,
"createdAt": CREATED_AT_ISO,
"updatedAt": UPDATED_AT_ISO,
"description": DESCRIPTION,
"hasDeployment": False,
"hasExperiment": True,
"hasPreDeployment": True,
}
self.assertDictEqual(expected, result)
expected = {
"uuid": EXPERIMENT_ID_2,
"name": NAME,
"projectId": PROJECT_ID_2,
"position": 0,
"isActive": True,
"operators": [],
}
self.assertEqual(len(result_experiments), 1)
machine_generated = ["createdAt", "updatedAt"]
for attr in machine_generated:
self.assertIn(attr, result_experiments[0])
del result_experiments[0][attr]
self.assertDictEqual(expected, result_experiments[0])
expected = {
"uuid": DEPLOYMENT_ID,
"name": NAME,
"projectId": PROJECT_ID_2,
"experimentId": EXPERIMENT_ID_2,
"position": POSITION,
"isActive": IS_ACTIVE,
"operators": [],
"url": URL,
"status": STATUS,
}
self.assertEqual(len(result_deployments), 1)
machine_generated = ["createdAt", "updatedAt", "deployedAt"]
for attr in machine_generated:
self.assertIn(attr, result_deployments[0])
del result_deployments[0][attr]
self.assertDictEqual(expected, result_deployments[0])
def test_update_project(self):
rv = TEST_CLIENT.patch("/projects/foo", json={})
result = rv.json()
expected = {"message": "The specified project does not exist"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 404)
rv = TEST_CLIENT.patch(f"/projects/{PROJECT_ID}", json={
"name": NAME_2,
})
result = rv.json()
expected = {"message": "a project with that name already exists"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 400)
#update project using the same name
rv = TEST_CLIENT.patch(f"/projects/{PROJECT_ID}", json={
"name": NAME,
})
self.assertEqual(rv.status_code, 200)
rv = TEST_CLIENT.patch(f"/projects/{PROJECT_ID}", json={
"name": "bar",
})
result = rv.json()
result_experiments = result.pop("experiments")
expected = {
"uuid": PROJECT_ID,
"name": "bar",
"description": DESCRIPTION,
"createdAt": CREATED_AT_ISO,
"hasPreDeployment": False,
"hasDeployment": False,
"hasExperiment": True,
"deployments": []
}
machine_generated = ["updatedAt"]
for attr in machine_generated:
self.assertIn(attr, result)
del result[attr]
self.assertDictEqual(expected, result)
expected = {
"uuid": EXPERIMENT_ID,
"name": NAME,
"projectId": PROJECT_ID,
"position": POSITION,
"isActive": IS_ACTIVE,
"operators": [],
}
self.assertEqual(len(result_experiments), 1)
machine_generated = ["createdAt", "updatedAt"]
for attr in machine_generated:
self.assertIn(attr, result_experiments[0])
del result_experiments[0][attr]
self.assertDictEqual(expected, result_experiments[0])
def test_delete_project(self):
rv = TEST_CLIENT.delete("/projects/unk")
result = rv.json()
expected = {"message": "The specified project does not exist"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 404)
rv = TEST_CLIENT.delete(f"/projects/{PROJECT_ID}")
result = rv.json()
expected = {"message": "Project deleted"}
self.assertDictEqual(expected, result)
def test_delete_projects(self):
rv = TEST_CLIENT.post("/projects/deleteprojects", json=[])
result = rv.json()
expected = {"message": "inform at least one project"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 400)
rv = TEST_CLIENT.post("/projects/deleteprojects", json=[PROJECT_ID_2])
result = rv.json()
expected = {"message": "Successfully removed projects"}
self.assertDictEqual(expected, result)
self.assertEqual(rv.status_code, 200)
|
py | 7dfee9fb93bacbbcdb7f578a10476d998fb4b1b6 | from __future__ import absolute_import, division, print_function
__all__ = [
"__title__", "__summary__", "__uri__", "__version__", "__author__",
"__email__", "__license__", "__copyright__",
]
__title__ = "phe"
__summary__ = "Partially Homomorphic Encryption library for Python"
__uri__ = "https://github.com/data61/python-paillier"
# We use semantic versioning - semver.org
__version__ = "1.4.1-dev0"
__author__ = "CSIRO's Data61"
__email__ = "[email protected]"
__license__ = "GPLv3"
__copyright__ = "Copyright 2013-2019 {0}".format(__author__)
|
py | 7dfeea9be624ddad0df7b6b278488a376103dc33 | import numpy as np
import matplotlib.pyplot as plt
import time,sys
nx = 41;
domain = np.linspace(0,2,nx);
dx = 2/(nx-1)
nt = 25
nu = 0.3
sigma = .2
dt = sigma * dx**2 / nu
u = np.ones(nx)
u[int(.5 / dx):int(1 / dx + 1)] = 2
un = np.ones(nx)
for n in range(nt):
un = u.copy()
for i in range(1, nx - 1):
u[i] = un[i] + nu * dt / dx**2 * (un[i+1] - 2 * un[i] + un[i-1])
#plt.plot(domain, u);
#plt.grid()
plt.plot(domain, u);
plt.grid() |
py | 7dfeeb516944fe0279830cd970068e94eb5bb60c | import threading
import time
import smtplib, ssl
import os
import schedule
carrier_dict = {"verizon": "vtext.com",
"tmobile": "tmomail.net",
"sprint": "messaging.sprintpcs.com",
"att": "txt.att.net"}
class server:
def __init__(self, threading = False):
self.threading = threading
self.refresh_interval = None
self.internal_scheduler = schedule.Scheduler()
self.emails = []
self.numbers = []
self.text_on = False
def __send_notification(self, msg):
print("HELLO")
context = ssl.create_default_context()
port = 465 # For SSL
with smtplib.SMTP_SSL("smtp.gmail.com", port, context=context) as server:
server.login(self.emails[0][0], self.emails[0][1])
for receiver_email in self.emails:
server.sendmail(self.emails[0][0], receiver_email, msg)
time.sleep(2)
if self.text_on:
for number in self.numbers:
print("sending text")
receiver_sms_gateway = str(number[0]) + "@" + carrier_dict[number[1]]
server.sendmail(self.emails[0][0], receiver_sms_gateway, msg)
def __update_refresh_interval(self, new_interval):
if not self.refresh_interval:
self.refresh_interval = new_interval * 60
else:
self.refresh_interval = min(self.refresh_interval, new_interval * 60)
def __transform_to_threaded_job(self, func):
def threaded_job():
t = threading.Thread(func)
t.start()
return threaded_job
def __notification_wrapper(self, func):
def notification_job():
notify, msg = func()
if notify:
self.__send_notification(msg)
return notification_job
def __add_job(self, func, m):
notif_wrapped_func = self.__notification_wrapper(func)
if self.threading:
notif_wrapped_func = self.__transform_to_threaded_job(notif_wrapped_func)
self.internal_scheduler.every(m).minutes.do(notif_wrapped_func)
def weekly_job(self, func):
self.__update_refresh_interval(60*24*7)
self.__add_job(func, 60 * 24 * 7)
def daily_job(self, func):
self.__update_refresh_interval(60*24)
self.__add_job(func, 60 * 24)
def hourly_job(self, func):
self.__update_refresh_interval(60)
self.__add_job(func, 60)
def minutely_job(self, func):
self.__update_refresh_interval(1)
self.__add_job(func, 1)
def register_email(self, email, password):
self.emails.append((email, password))
def register_number(self, number, carrier):
self.text_on = True
self.numbers.append((number, carrier))
def start(self):
if self.refresh_interval is None:
raise Exception("atleast one job must be specified")
if not len(self.emails):
raise Exception("register email before starting")
while True:
self.internal_scheduler.run_pending()
time.sleep(self.refresh_interval)
if __name__ == '__main__':
# port = 465 # For SSL
# sender_email = os.environ['EMAIL1']
# password = os.environ['EMAIL_PASS']
#
# receiver_email = os.environ['EMAIL2']
# message = """\
# Subject: Hi there
#
# This message is sent from Python."""
#
# # Create a secure SSL context
# context = ssl.create_default_context()
#
# receiver_sms_gateway = "2488805628" + "@" + "pm.sprint.com"
#
# with smtplib.SMTP_SSL("smtp.gmail.com", port, context=context) as server:
# server.login(sender_email, password)
# server.sendmail(sender_email, receiver_sms_gateway, message)
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
message = MIMEMultipart()
message['From'] = "[email protected]"
message['To'] = "2488805628" + "@" + carrier_dict["sprint"]
message['Subject'] = "Sent from Arun!"
text = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
% (message['From'], ", ".join(message['To']), message['Subject']))
text += "Hello World!\r\n"
text = "\r\nHello World!"
message.attach(MIMEText(text.encode("utf-8"), "plain", "utf-8"))
server = smtplib.SMTP("smtp.gmail.com", 587)
server.starttls()
server.login(message["From"], "Liculdedav8")
# server.sendmail(message["From"], [message["To"]], text)
server.send_message(message)
|
py | 7dfeeb7892d42a86a5c34d94ef679590ed2e8154 | # -*- coding: utf-8 -*-
import requests
import json
import time
token = 'xoxp-TOKEN' # 슬랙 RTM(Real Time Messaging) API 토큰
hook_url = 'https://' # 슬랙 Incoming Webhook URL
bot_name = '' # 슬랙 메시지에 쓰일 봇 이름
channel_id = "#channel_id" # 채널 ID
api_files_list = 'https://slack.com/api/files.list'
second_day = 60 * 60 * 24
ts_to = time.time() - 60 * second_day
data = {'token': token, 'ts_to': ts_to, 'types': 'images', 'count': 1000, 'page': 1}
response = requests.post(api_files_list, data = data)
num_total = response.json()['paging']['total']
num_pages = response.json()['paging']['pages']
print "files: {}\npages: {}".format(num_total, num_pages)
list_starred = []
list_private = []
list_delete = []
delete_size = 0
if len(response.json()['files']) == 0:
exit(0)
for p in range(1, num_pages+1):
print "Current page: {}".format(p)
data = {'token': token, 'ts_to': ts_to, 'types': 'images', 'count': 1000, 'page': p}
response = requests.post(api_files_list, data = data)
for f in response.json()['files']:
try:
f['num_stars']
list_starred.append(f['id'])
except:
if f['is_public'] == False:
list_private.append(f['id'])
else:
list_delete.append(f['id'])
delete_size += f['size']
print "Starred files count: {}".format(len(list_starred))
print "Private files count: {}".format(len(list_private))
print "Deleting files count: {}".format(len(list_delete))
print "Starred files: {}".format(list_starred)
print "Total size to be cleaned: {}".format(delete_size)
def call_delete(delete_list):
global token
api_files_delete = 'https://slack.com/api/files.delete'
list_success = []
list_fail = []
for f in delete_list:
data = {'token': token, 'file': f}
response = requests.post(api_files_delete, data = data)
if response.json()['ok'] == True:
list_success.append(f)
print "Deletion succeed: {}".format(f)
else:
list_fail.append(f)
print "Deletion failed: {}".format(f)
print "Succeed files count: {}".format(len(list_success))
print "Failed files count: {}".format(len(list_fail))
print "Failed files: {}".format(list_fail)
def call_report(num_delete, delete_size):
json_channel = channel_id
json_fallback = "슬랙 청소 결과"
json_title = "슬랙 청소 결과"
json_text = "슬랙에 올라온지 60일이 지난 *사진 파일* 들을 일괄 삭제 완료하였습니다\n*별표(star)* 되어있거나, *비공개 채널* 혹은 *DM* 에서 공유된 사진들은 삭제 대상에서 *제외* 되었습니다"
json_value1 = num_delete
json_value2 = delete_size
requests.post(hook_url, json.dumps({
"channel": json_channel,
"username": bot_name,
"attachments": [
{
"fallback": json_fallback,
"title": json_title,
"text": json_text,
"mrkdwn_in": ["text"],
"fields": [
{
"title": "삭제된 사진 개수",
"value": json_value1,
"short": "true"
},
{
"title": "비워진 용량",
"value": json_value2,
"short": "true"
}
],
"color": "#1DAFED"
}
]
}))
# byte로 표기된 파일 크기를 사람이 읽을 수 있는 단위로 바꿈
suffixes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
def human_readable(nbytes):
if nbytes == 0: return '0 B'
i = 0
while nbytes >= 1024 and i < len(suffixes)-1:
nbytes /= 1024.
i += 1
f = ('%.2f' % nbytes).rstrip('0').rstrip('.')
return '%s%s' % (f, suffixes[i])
# 실행
call_delete(list_delete)
call_report(len(list_delete), human_readable(delete_size))
|
py | 7dfeec5e3739e49bda37729f586b600ae7385763 | from reapy.errors import DisconnectedClientError, DistError
from reapy.tools import json
from .socket import Socket
class Client(Socket):
def __init__(self, port):
super(Client, self).__init__()
self._connect(port)
def _connect(self, port):
super(Client, self).connect(("localhost", port))
self.address = self.recv(timeout=None).decode("ascii")
def _get_result(self):
s = self.recv(timeout=None).decode()
return json.loads(s)
def run_program(self, program, input):
"""
Send a program to the server and return its output.
Parameters
----------
program : reapy.tools.Program
Program to run.
input : dict
Input to the program.
Returns
-------
result
Program output
Raises
------
DistError
When an error occurs while the server runs the program, its
traceback is sent to the client and used to raise a
DistError.
"""
program = program.to_dict()
request = {"program": program, "input": input}
request = json.dumps(request).encode()
self.send(request)
result = self._get_result()
if result["type"] == "result":
return result["value"]
elif result["type"] == "error":
raise DistError(result["traceback"])
|
py | 7dfeedff4762d3cad73e96ce9eb2b5dd4150f001 | from typing import Any
import pytest
from intents import Sys, LanguageCode, Entity
from intents.model.entity import SystemEntityMixin
from intents.resources.builtin_entities.color import I_IntentsColor
from intents.connectors.interface import entity_mappings
def test_string_entity_mapping():
mapping = entity_mappings.StringEntityMapping(Sys.Integer, "@FakeInteger")
assert mapping.entity_cls == Sys.Integer
assert mapping.service_name == "@FakeInteger"
assert mapping.from_service("42") == Sys.Integer("42")
assert mapping.to_service(42) == "42"
def test_patched_entity_mapping():
mapping = entity_mappings.PatchedEntityMapping(Sys.Color, I_IntentsColor)
assert mapping.entity_cls == Sys.Color
assert mapping.service_name == "I_IntentsColor"
assert mapping.from_service("red") == Sys.Color("red")
assert mapping.to_service(Sys.Color("red")) == "red"
#
# ServiceEntityMappings
#
class MockCustomMapping(entity_mappings.EntityMapping):
entity_cls = Sys.Person
service_name = "@FakePerson"
supported_languages = [LanguageCode.ENGLISH]
def from_service(self, service_data: Any) -> SystemEntityMixin:
return Sys.Person(service_data["name"])
def to_service(self, entity: SystemEntityMixin) -> Any:
return str({"name": entity})
MOCK_MAPPINGS = entity_mappings.ServiceEntityMappings.from_list([
entity_mappings.StringEntityMapping(Sys.PhoneNumber, "@FakePhoneNumber"),
MockCustomMapping()
])
def test_mappings__sys_found():
mapping = MOCK_MAPPINGS.lookup(Sys.PhoneNumber)
assert mapping == entity_mappings.StringEntityMapping(Sys.PhoneNumber, "@FakePhoneNumber")
assert MOCK_MAPPINGS.service_name(Sys.PhoneNumber) == "@FakePhoneNumber"
assert MOCK_MAPPINGS.is_mapped(Sys.PhoneNumber, LanguageCode.ENGLISH)
assert MOCK_MAPPINGS.is_mapped(Sys.PhoneNumber, LanguageCode.SPANISH_LATIN_AMERICA)
def test_mappings__supported_languages():
mapping = MOCK_MAPPINGS.lookup(Sys.Person)
assert isinstance(mapping, MockCustomMapping)
assert MOCK_MAPPINGS.service_name(Sys.Person) == "@FakePerson"
assert MOCK_MAPPINGS.is_mapped(Sys.Person, LanguageCode.ENGLISH)
assert not MOCK_MAPPINGS.is_mapped(Sys.Person, LanguageCode.SPANISH_LATIN_AMERICA)
def test_mappings__sys_not_found():
with pytest.raises(KeyError):
MOCK_MAPPINGS.lookup(Sys.Color)
assert not MOCK_MAPPINGS.is_mapped(Sys.Color, LanguageCode.ENGLISH)
def test_mappings__custom_entity():
class MyCustomEntity(Entity):
pass
mapping = MOCK_MAPPINGS.lookup(MyCustomEntity)
assert mapping == entity_mappings.StringEntityMapping(
entity_cls=MyCustomEntity,
service_name="MyCustomEntity"
)
assert MOCK_MAPPINGS.service_name(MyCustomEntity) == "MyCustomEntity"
|
py | 7dfeee00242ed6334620f58a54180906ac3512af | import os
if __name__ == '__main__':
small_data_set_lst = ['ca-GrQc', 'ca-HepTh', 'p2p-Gnutella06', 'wiki-Vote']
data_set_lst = [
# 'email-Enron', 'email-EuAll',
# 'web-NotreDame', 'web-Stanford', 'web-BerkStan', 'web-Google', 'cit-Patents',
# 'soc-LiveJournal1',
# 'wiki-Link',
'digg-friends',
'flickr-growth',
]
generate_exec_path = '/homes/ywangby/workspace/yche/new-git-repos-yche/SimRank/LPMC-Profile/build/util/bin_converter'
for data_set in small_data_set_lst + data_set_lst:
cmd = ' '.join(map(str, [generate_exec_path, data_set]))
print cmd
os.system(cmd)
|
py | 7dfeee87389b8f757d22190acccf7e15c7b16c16 | from django.contrib import admin
from prozhito_app.models import *
# Register your models here.
from django.contrib.gis import admin
from mapwidgets.widgets import GooglePointFieldWidget
class PersonAdmin(admin.ModelAdmin):
search_fields = ['first_name', 'patronymic', 'family_name',]
list_filter = ['from_tags', 'from_natasha']
admin.site.register(Person, PersonAdmin)
class PlaceAdmin(admin.ModelAdmin):
search_fields = ['name',]
formfield_overrides = {
models.PointField: {"widget": GooglePointFieldWidget}
}
admin.site.register(Place, PlaceAdmin)
class EntryAdmin(admin.ModelAdmin):
search_fields = ['id', ]
list_filter = ['sentiment']
autocomplete_fields = ['people', 'keywords']
admin.site.register(Entry, EntryAdmin)
class KeywordAdmin(admin.ModelAdmin):
search_fields = ['name',]
admin.site.register(Keyword, KeywordAdmin)
class DiaryAdmin(admin.ModelAdmin):
search_fields = ['id',]
list_filter = ['no_entries','first_note', 'last_note']
admin.site.register(Diary, DiaryAdmin)
|
py | 7dfeef0e847518ae997fc5244cc2a1e2aca3416f | import matplotlib.pyplot as plt
import plotly.express as px
import pandas as pd
article_csv = './Data/Original Data/articles.csv'
customer_csv = './Data/Original Data/customers.csv'
tx_csv = './Data/Original Data/transections_train.csv'
wage_csv = './Data/Original Data/Iowa_Wage_Data_by_Occupation.csv'
article_df = pd.read_csv(article_csv)
article_df.head()
print("shape of data article data", article_df.shape)
customer_df = pd.read_csv(customer_csv)
customer_df.head()
print("shape of data customer data", customer_df.shape)
tx_df = pd.read_csv(tx_csv)
tx_df.head()
print("shape of data transections data", tx_df.shape)
# Function to plot the Nan percentages of each columns
def plot_nas(df: pd.DataFrame):
if df.isnull().sum().sum() != 0:
na_df = (df.isnull().sum() / len(df)) * 100
# rearrange the last col
# cols = df.columns.to_list()
# cols = cols[-1:] + cols[:-1]
# na_df = na_df[cols]
# delete the 0 % col
# na_df = na_df.drop(na_df[na_df == 0].index).sort_values(ascending=False)
missing_data = pd.DataFrame({'Missing Ratio %': na_df})
missing_data.plot(kind="barh")
plt.show()
else:
print('No NAs found')
print("Checking null in data")
plot_nas(article_df)
plot_nas(customer_df)
plot_nas(tx_df)
def plot_bar(df, column):
long_df = pd.DataFrame(
df.groupby(column)['customer_id'].count().reset_index().rename({'customer_id': 'count'},
axis=1))
fig = px.bar(long_df, x=column, y="count", color=column, title=f"bar plot for {column} ")
fig.show()
def plot_hist(df, column):
fig = px.histogram(df, x=column, nbins=10, title=f'{column} distribution ')
fig.show()
def plot_bar(df, column):
long_df = pd.DataFrame(
df.groupby(column)['article_id'].count().reset_index().rename({'article_id': 'count'},
axis=1))
fig = px.bar(long_df, x=column, y="count", color=column, title=f"bar plot for {column} ")
fig.show()
def plot_hist(df, column):
fig = px.histogram(df, x=column, nbins=10, title=f'{column} distribution ')
fig.show()
plot_bar(customer_df, 'age')
plot_bar(customer_df, 'postal_code')
plot_bar(customer_df, 'product_type_name')
plot_bar(customer_df, 'product_group_name')
plot_bar(customer_df, 'graphical_appearance_name')
plot_bar(customer_df, 'index_name')
plot_bar(customer_df, 'garment_group_name')
|
py | 7dfef032ba47384edda838e5d65730d7e18b3624 | # Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
import json
import logging
import os
from nni.tuner import Tuner
from nni.utils import extract_scalar_reward
_logger = logging.getLogger('NaiveTuner')
_logger.info('start')
_pwd = os.path.dirname(__file__)
_result = open(os.path.join(_pwd, 'tuner_result.txt'), 'w')
class NaiveTuner(Tuner):
def __init__(self, optimize_mode):
self.cur = 0
_logger.info('init')
def generate_parameters(self, parameter_id, **kwargs):
self.cur += 1
_logger.info('generate parameters: %s' % self.cur)
return { 'x': self.cur }
def receive_trial_result(self, parameter_id, parameters, value, **kwargs):
reward = extract_scalar_reward(value)
_logger.info('receive trial result: %s, %s, %s' % (parameter_id, parameters, reward))
_result.write('%d %d\n' % (parameters['x'], reward))
_result.flush()
def update_search_space(self, search_space):
_logger.info('update_search_space: %s' % search_space)
with open(os.path.join(_pwd, 'tuner_search_space.json'), 'w') as file_:
json.dump(search_space, file_)
def _on_exit(self):
_result.close()
def _on_error(self):
_result.write('ERROR\n')
_result.close()
|
py | 7dfef18b3316b29654401f9a343e91bdb73824c7 | #!/usr/bin/env python
import rospy
import math
import time
import sys, select, termios, tty
import os
from std_msgs.msg import Empty
import geometry_msgs.msg
from geometry_msgs.msg import Twist
from geometry_msgs.msg import TwistStamped
x = 0
y = 0
z = 0
from Tkinter import *
import ttk
import threading
import ars_control
import subprocess
global window
window= Tk()
window.config(background= "#41B77F")
prompt='Click any button, or press a key'
L = Label(window, text=prompt, width=len(prompt))
L.pack()
cmd = """
#!/bin/bash
echo "Stopping Robot":
rostopic pub -1 /robot_cmd_stamped geometry_msgs/TwistStamped "
header:
seq: 0
stamp:
secs: 0
nsecs: 0
frame_id: ''
twist:
linear:
x: 0.0
y: 0.0
z: 0.0
angular:
x: 0.0
y: 0.0
z: 0.0"
"""
def key(event):
if event.char == event.keysym:
msg ='Normal Key %r' % event.char
elif len(event.char) == 1:
msg ='Punctuation Key %r (%r)' % (event.keysym, event.char)
else:
msg ='Special Key %r' % event.keysym
L.config(text=msg)
L.bind_all('<Key>', key)
def do_mouse(eventname):
def mouse_binding(event):
msg = 'Mouse event %s' % eventname
L.config(text=msg)
L.bind_all('<%s>'%eventname, mouse_binding)
for i in range(1,4):
do_mouse('Button-%s' % i)
do_mouse('ButtonRelease-%s' % i)
do_mouse('Double-Button-%s' % i)
def quit():
distro = window.destroy()
exit = sys.exit()
return distro, exit
def getdistance():
distance = float(distance_selected.get())
return distance
def getspeed():
speed = float(speed_selected.get())
return speed
def stop_moving():
t = threading.Thread(target=os.system(cmd))
t.start()
return
def moveforward_background():
speed= getspeed()
distance=getdistance()
t = threading.Thread(target= ars_control.moveX(speed, distance, True))
t.start()
def moveback_background():
speed= getspeed()
distance=getdistance()
t = threading.Thread(target= ars_control.moveX(speed, distance, False))
t.start()
def moveleft_background():
speed= getspeed()
distance=getdistance()
t = threading.Thread(target= ars_control.moveY(speed, distance, True))
t.start()
def moveright_background():
speed= getspeed()
distance=getdistance()
t = threading.Thread(target= ars_control.moveY(speed, distance, False))
t.start()
def return_home():
t = threading.Thread(target= ars_control.control())
t.start()
def goup_background():
speed= getspeed()
distance=getdistance()
t = threading.Thread(target= ars_control.moveZ(speed, distance, True))
t.start()
def godown_background():
speed= getspeed()
distance=getdistance()
t = threading.Thread(target= ars_control.moveZ(speed, distance, False))
t.start()
def rotationmoveleft_background():
t = threading.Thread(target= ars_control.rotate(10, 65, True))
t.start()
def rotationmoveright_background():
t = threading.Thread(target= ars_control.rotate(10, 65, False))
t.start()
#Define a callback function for exit
def quit_program(e):
window.destroy()
if __name__ == '__main__':
try:
rospy.init_node('ars_remote_controller_test', anonymous=True)
position_topic = "/robot_cmd_stamped" #(change me /robot_cmd_stamped)
pose_publisher = rospy.Publisher(position_topic, TwistStamped, queue_size=1)
label_title= Label(window, text= "Controller", font=("Courrier",40), bg = "#41B77F", fg= "white")
label_title.pack()
window.title("Nao_Drone")
window.geometry("1080x600")
window.minsize(1000,500)
#user choice of speed and distance
speed_label= Label(window,text = "Distance").place(x=30,y=50)
distance_label= Label(window, text= "Speed").place(x=740,y=50)
distance_var= StringVar()
distance_selected= ttk.Combobox(window, width=20,textvariable=distance_var)
distance_selected['values']=('0.1','0.2','0.3','0.5')
distance_selected.place(x=800,y=50)
distance_selected.current(0)
speed_var= StringVar()
speed_selected= ttk.Combobox(window, width=20,textvariable=speed_var)
speed_selected['values']=('0.1','0.2','0.3','0.5')
speed_selected.place(x=80,y=50)
speed_selected.current(0)
moveforward_button = Button(window, text="Move Forward", height= "3", width="20",command = moveforward_background).place(x=450,y=150)
moveback_button= Button(window, text="Move Back", height= "3", width="20", command = moveback_background).place(x=450,y=350)
moveleft_button= Button(window, text="Move Left", height= "3", width="20", command= moveleft_background).place(x=350,y=250)
moveright_button = Button(window, text="Move Right", height= "3", width="20", command = moveright_background).place(x=550,y=250)
goup_button = Button(window, text= "Go Up", height="3", width="20", command= goup_background).place(x = 450, y = 450)
godown_button = Button(window, text= "Go Down", height="3", width= "20", command= godown_background).place(x= 450, y =520)
quit_button = Button(window, text= "Quit Interface", height = "3", width= "20", command = quit).place(x=30, y= 300)
init_state_button = Button(window, text= "Stop moving", height = "3", width= "20", command = stop_moving).place(x=30, y= 420)
rotationmoveleft_button= Button(window, text= "Rotate to the left", height="3", width= "20", command= rotationmoveleft_background).place(x=800, y=450)
rotationmoveright_button = Button(window, text = "Rotate to the right", height="3", width= "20", command= rotationmoveright_background).place(x=800,y=520)
#Add a Label widget
label = Label(window, text= "Press Ctrl + x to Exit", font= ('Helvetica 15 bold'))
label.pack(pady=10)
#Bind the Keyboard shortcut Key
window.bind('<Control-x>', quit_program)
window.mainloop()
while True:
window.mainloop()
except rospy.ROSInterruptException:
rospy.loginfo("node terminated.") |
py | 7dfef2219106ca2966dacef581d8268b98b2b5c8 | from django.urls import include, path
from . import views
urlpatterns = [
path('', views.home, name='home'),
path('landing/', views.mainApp, name='index'),
] |
py | 7dfef26fa2b939da0ab58954cd990865cf387abc | """Functions for running energy evluations with OpenMM."""
from typing import Dict, Optional
import numpy as np
import openmm
from openmm import unit
from openff.interchange.components.interchange import Interchange
from openff.interchange.drivers.report import EnergyReport
kj_mol = unit.kilojoule_per_mole
def get_openmm_energies(
off_sys: Interchange,
round_positions: Optional[int] = None,
hard_cutoff: bool = False,
electrostatics: bool = True,
combine_nonbonded_forces: bool = False,
) -> EnergyReport:
"""
Given an OpenFF Interchange object, return single-point energies as computed by OpenMM.
.. warning :: This API is experimental and subject to change.
Parameters
----------
off_sys : openff.interchange.components.interchange.Interchange
An OpenFF Interchange object to compute the single-point energy of
round_positions : int, optional
The number of decimal places, in nanometers, to round positions. This can be useful when
comparing to i.e. GROMACS energies, in which positions may be rounded.
writer : str, default="internal"
A string key identifying the backend to be used to write OpenMM files. The
default value of `"internal"` results in this package's exporters being used.
hard_cutoff : bool, default=True
Whether or not to apply a hard cutoff (no switching function or disperson correction)
to the `openmm.NonbondedForce` in the generated `openmm.System`. Note that this will
truncate electrostatics to the non-bonded cutoff.
electrostatics : bool, default=True
A boolean indicating whether or not electrostatics should be included in the energy
calculation.
combine_nonbonded_forces : bool, default=False
Whether or not to combine all non-bonded interactions (vdW, short- and long-range
ectrostaelectrostatics, and 1-4 interactions) into a single openmm.NonbondedForce.
Returns
-------
report : EnergyReport
An `EnergyReport` object containing the single-point energies.
"""
positions = off_sys.positions
if "VirtualSites" in off_sys.handlers:
if len(off_sys["VirtualSites"].slot_map) > 0:
if not combine_nonbonded_forces:
raise NotImplementedError(
"Cannot yet split out NonbondedForce components while virtual sites are present."
)
n_virtual_sites = len(off_sys["VirtualSites"].slot_map)
# TODO: Actually compute virtual site positions based on initial conformers
virtual_site_positions = np.zeros((n_virtual_sites, 3))
virtual_site_positions *= off_sys.positions.units
positions = np.vstack([positions, virtual_site_positions])
omm_sys: openmm.System = off_sys.to_openmm(
combine_nonbonded_forces=combine_nonbonded_forces
)
return _get_openmm_energies(
omm_sys=omm_sys,
box_vectors=off_sys.box,
positions=positions,
round_positions=round_positions,
hard_cutoff=hard_cutoff,
electrostatics=electrostatics,
)
def _get_openmm_energies(
omm_sys: openmm.System,
box_vectors,
positions,
round_positions=None,
hard_cutoff=False,
electrostatics: bool = True,
) -> EnergyReport:
"""Given a prepared `openmm.System`, run a single-point energy calculation."""
"""\
if hard_cutoff:
omm_sys = _set_nonbonded_method(
omm_sys, "cutoff", electrostatics=electrostatics
)
else:
omm_sys = _set_nonbonded_method(omm_sys, "PME")
"""
for idx, force in enumerate(omm_sys.getForces()):
force.setForceGroup(idx)
integrator = openmm.VerletIntegrator(1.0 * unit.femtoseconds)
context = openmm.Context(omm_sys, integrator)
if box_vectors is not None:
if not isinstance(box_vectors, (unit.Quantity, list)):
box_vectors = box_vectors.magnitude * unit.nanometer
context.setPeriodicBoxVectors(*box_vectors)
if isinstance(positions, unit.Quantity):
# Convert list of Vec3 into a NumPy array
positions = np.asarray(positions.value_in_unit(unit.nanometer)) * unit.nanometer
else:
positions = positions.magnitude * unit.nanometer
if round_positions is not None:
rounded = np.round(positions, round_positions)
context.setPositions(rounded)
else:
context.setPositions(positions)
raw_energies = dict()
omm_energies = dict()
for idx in range(omm_sys.getNumForces()):
state = context.getState(getEnergy=True, groups={idx})
raw_energies[idx] = state.getPotentialEnergy()
del state
# This assumes that only custom forces will have duplicate instances
for key in raw_energies:
force = omm_sys.getForce(key)
if type(force) == openmm.HarmonicBondForce:
omm_energies["HarmonicBondForce"] = raw_energies[key]
elif type(force) == openmm.HarmonicAngleForce:
omm_energies["HarmonicAngleForce"] = raw_energies[key]
elif type(force) == openmm.PeriodicTorsionForce:
omm_energies["PeriodicTorsionForce"] = raw_energies[key]
elif type(force) in [
openmm.NonbondedForce,
openmm.CustomNonbondedForce,
openmm.CustomBondForce,
]:
energy_type = _infer_nonbonded_energy_type(force)
if energy_type == "None":
continue
if energy_type in omm_energies:
omm_energies[energy_type] += raw_energies[key]
else:
omm_energies[energy_type] = raw_energies[key]
# Fill in missing keys if interchange does not have all typical forces
for required_key in [
"HarmonicBondForce",
"HarmonicAngleForce",
"PeriodicTorsionForce",
"NonbondedForce",
]:
if not any(required_key in val for val in omm_energies):
pass # omm_energies[required_key] = 0.0 * kj_mol
del context
del integrator
report = EnergyReport()
report.update_energies(
{
"Bond": omm_energies.get("HarmonicBondForce", 0.0 * kj_mol),
"Angle": omm_energies.get("HarmonicAngleForce", 0.0 * kj_mol),
"Torsion": _canonicalize_torsion_energies(omm_energies),
}
)
if "Nonbonded" in omm_energies:
report.update_energies(
{"Nonbonded": _canonicalize_nonbonded_energies(omm_energies)}
)
report.energies.pop("vdW")
report.energies.pop("Electrostatics")
else:
report.update_energies({"vdW": omm_energies.get("vdW", 0.0 * kj_mol)})
report.update_energies(
{"Electrostatics": omm_energies.get("Electrostatics", 0.0 * kj_mol)}
)
return report
def _infer_nonbonded_energy_type(force):
if type(force) == openmm.NonbondedForce:
has_electrostatics = False
has_vdw = False
for i in range(force.getNumParticles()):
if has_electrostatics and has_vdw:
continue
params = force.getParticleParameters(i)
if not has_electrostatics:
if params[0]._value != 0:
has_electrostatics = True
if not has_vdw:
if params[2]._value != 0:
has_vdw = True
if has_electrostatics and not has_vdw:
return "Electrostatics"
if has_vdw and not has_electrostatics:
return "vdW"
if has_vdw and has_electrostatics:
return "Nonbonded"
if not has_vdw and not has_electrostatics:
return "None"
if type(force) == openmm.CustomNonbondedForce:
if "epsilon" or "sigma" in force.getEnergyFunction():
return "vdW"
if type(force) == openmm.CustomBondForce:
if "qq" in force.getEnergyFunction():
return "Electrostatics"
else:
return "vdW"
raise Exception(type(force))
def _canonicalize_nonbonded_energies(energies: Dict):
omm_nonbonded = 0.0 * kj_mol
for key in [
"Nonbonded",
"NonbondedForce",
"CustomNonbondedForce",
"CustomBondForce",
]:
try:
omm_nonbonded += energies[key]
except KeyError:
pass
return omm_nonbonded
def _canonicalize_torsion_energies(energies: Dict):
omm_torsion = 0.0 * kj_mol
for key in ["PeriodicTorsionForce", "RBTorsionForce"]:
try:
omm_torsion += energies[key]
except KeyError:
pass
return omm_torsion
|
py | 7dfef2c7aa7709569ef8f490a2a8ae6fe1618867 | """
Script for dumping filtered DB data per Django's dumpdata.
This is intended as a one-time script, so filters are hard-coded. We can add arguments
later if this gets more use.
"""
from typing import Dict, Any, List, Union
import os
import sys
import json
from datetime import date, datetime
import django
from django.db.models import Model, Q
from django.conf import settings
from mypy_extensions import TypedDict
PROJECT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../"))
if PROJECT_PATH not in sys.path:
sys.path.append(PROJECT_PATH)
django.setup()
from server.models import Prediction # pylint: disable=wrong-import-position
DumpRecord = TypedDict(
"DumpRecord", {"model": str, "pk": int, "fields": Dict[str, Any]}
)
APP_NAME = "server"
def _clean_value(value: Any) -> Union[str, int, float]:
if type(value) in [datetime, date]: # pylint: disable=unidiomatic-typecheck
return str(value)
return value
def _reshape_record_fields(model_name: str, record: Dict[str, Any]) -> DumpRecord:
fields = {k: _clean_value(v) for k, v in record.items() if k != "id"}
return {"model": APP_NAME + "." + model_name, "pk": record["id"], "fields": fields}
def _get_fields_for(model_class: Model) -> List[str]:
return [
field.attname
for field in model_class._meta.get_fields() # pylint: disable=protected-access
# Association fields appear in list, but aren't attributes
# unless the given record has the foreign key.
if hasattr(field, "attname")
]
def main():
"""Dump filtered DB data per Django's dumpdata."""
season_2019_preds_for_tipresias_2020 = Q(ml_model__name="tipresias_2020") & Q(
match__start_date_time__year=2019
)
season_2020_preds_for_round_1 = Q(match__start_date_time__year=2020) & (
Q(match__round_number=1)
)
prediction_records = Prediction.objects.filter(
season_2019_preds_for_tipresias_2020 | season_2020_preds_for_round_1
).values(*_get_fields_for(Prediction))
prediction_dump = [
_reshape_record_fields("prediction", record) for record in prediction_records
]
dump_filepath = os.path.join(
settings.BASE_DIR,
APP_NAME,
"fixtures",
f"{date.today()}-prediction-dump.json",
)
with open(dump_filepath, "w", encoding="utf-8") as file:
json.dump(prediction_dump, file, indent=2)
if __name__ == "__main__":
main()
|
py | 7dfef301548a37737a791de6404e218399b2d84c | # Copyright 2014 Google Inc. All Rights Reserved.
#
# 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.
"""Backend service."""
from googlecloudsdk.api_lib.compute import utils
from googlecloudsdk.calliope import exceptions
class BackendService(object):
"""Abstracts BackendService resource."""
def __init__(self, ref, compute_client=None):
self.ref = ref
self._compute_client = compute_client
@property
def _client(self):
return self._compute_client.apitools_client
@property
def _messages(self):
return self._compute_client.messages
def _MakeGetRequestTuple(self):
region = getattr(self.ref, 'region', None)
if region is not None:
return (self._client.regionBackendServices, 'Get',
self._messages.ComputeRegionBackendServicesGetRequest(
project=self.ref.project,
region=region,
backendService=self.ref.Name()))
else:
return (self._client.backendServices, 'Get',
self._messages.ComputeBackendServicesGetRequest(
project=self.ref.project, backendService=self.ref.Name()))
def _MakeDeleteRequestTuple(self):
region = getattr(self.ref, 'region', None)
if region is not None:
return (self._client.regionBackendServices, 'Delete',
self._messages.ComputeRegionBackendServicesDeleteRequest(
project=self.ref.project,
region=region,
backendService=self.ref.Name()))
else:
return (self._client.backendServices, 'Delete',
self._messages.ComputeBackendServicesDeleteRequest(
project=self.ref.project, backendService=self.ref.Name()))
def _MakeGetHealthRequestTuple(self, group):
region = getattr(self.ref, 'region', None)
if region is not None:
return (self._client.regionBackendServices, 'GetHealth',
self._messages.ComputeRegionBackendServicesGetHealthRequest(
resourceGroupReference=self._messages.ResourceGroupReference(
group=group),
project=self.ref.project,
region=region,
backendService=self.ref.Name()))
else:
return (self._client.backendServices, 'GetHealth',
self._messages.ComputeBackendServicesGetHealthRequest(
resourceGroupReference=self._messages.ResourceGroupReference(
group=group),
project=self.ref.project,
backendService=self.ref.Name()))
def _MakeSetSecurityPolicyRequestTuple(self, security_policy):
region = getattr(self.ref, 'region', None)
if region is not None:
raise exceptions.InvalidArgumentException(
'region', 'Can only set security policy for global backend services.')
return (
self._client.backendServices, 'SetSecurityPolicy',
self._messages.ComputeBackendServicesSetSecurityPolicyRequest(
securityPolicyReference=self._messages.SecurityPolicyReference(
securityPolicy=security_policy),
project=self.ref.project,
backendService=self.ref.Name()))
def Delete(self, only_generate_request=False):
requests = [self._MakeDeleteRequestTuple()]
if not only_generate_request:
return self._compute_client.MakeRequests(requests)
return requests
def Get(self, only_generate_request=False):
"""Fetches the backend service resource."""
requests = [self._MakeGetRequestTuple()]
if not only_generate_request:
responses = self._compute_client.MakeRequests(requests)
return responses[0]
return requests
def GetHealth(self):
"""Issues series of gethealth requests for each backend group.
Yields:
{'backend': backend.group, 'status': backend_service.GetHealthResponse}
"""
backend_service = self.Get()
# Call GetHealth for each group in the backend service
# Instead of batching-up all requests and making a single
# request_helper.MakeRequests call, go one backend at a time.
# We do this because getHealth responses don't say what resource
# they correspond to. It's not obvious how to reliably match up
# responses and backends when there are errors. Additionally the contract
# for batched requests doesn't guarantee response order will match
# request order.
#
# TODO(b/25015230): Make a single batch request once the response
# can be mapped back to resource.
errors = []
for backend in backend_service.backends:
# The list() call below is itended to force the generator returned by
# MakeRequests. If there are exceptions the command will abort, which is
# expected. Having a list simplifies some of the checks that follow.
resources = self._compute_client.MakeRequests(
[self._MakeGetHealthRequestTuple(backend.group)], errors)
# For failed request error information will accumulate in errors
if resources:
yield {'backend': backend.group, 'status': resources[0]}
if errors:
utils.RaiseToolException(
errors, error_message='Could not get health for some groups:')
def SetSecurityPolicy(self, security_policy='', only_generate_request=False):
"""Sets the security policy for the backend service."""
requests = [self._MakeSetSecurityPolicyRequestTuple(security_policy)]
if not only_generate_request:
return self._compute_client.MakeRequests(requests)
return requests
|
py | 7dfef4347f044e8a3b2e68475e3d6960a068124d | #-*- coding:utf-8 -*-
from kivy.lang import Builder
from kivy.uix.screenmanager import Screen
from kivy.uix.floatlayout import FloatLayout
from kivy.properties import ObjectProperty
Builder.load_file("kvdialog/playmenu.kv")
class CBoxContainer(FloatLayout):
pass
class CPlayMenu(Screen):
m_BoxContainer = ObjectProperty()
def __init__(self, **kwargs):
super(CPlayMenu, self).__init__(**kwargs)
self.m_BoxManager = None
def buildboxs(self):
self.m_BoxContainer.clear_widgets() |
py | 7dfef46908f3c44ac0ede35ec5fc921605cf0d6f | #!/usr/bin/env python3
# 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.
"""
List all Anti-DDoS Floating IPs and limit the output with query parameters.
"""
import openstack
openstack.enable_logging(True)
conn = openstack.connect(cloud='otc')
for fip in conn.anti_ddos.floating_ips():
print(fip)
|
py | 7dfef49b380d910253fe9394219234ca21a2948e | """
This file will be copied to a temporary directory in order to
exercise caching compiled Numba functions.
See test_dispatcher.py.
"""
import sys
import numpy as np
from numba import jit, generated_jit, types, prange
from numba.tests.ctypes_usecases import c_sin
from numba.tests.support import TestCase, captured_stderr
@jit(cache=True, nopython=True)
def simple_usecase(x):
return x
def simple_usecase_caller(x):
return simple_usecase(x)
@jit(cache=True, nopython=True)
def add_usecase(x, y):
return x + y + Z
@jit(cache=True, forceobj=True)
def add_objmode_usecase(x, y):
object()
return x + y + Z
@jit(nopython=True)
def add_nocache_usecase(x, y):
return x + y + Z
@generated_jit(cache=True, nopython=True)
def generated_usecase(x, y):
if isinstance(x, types.Complex):
def impl(x, y):
return x + y
else:
def impl(x, y):
return x - y
return impl
@jit(cache=True, nopython=True)
def inner(x, y):
return x + y + Z
@jit(cache=True, nopython=True)
def outer(x, y):
return inner(-y, x)
@jit(cache=False, nopython=True)
def outer_uncached(x, y):
return inner(-y, x)
@jit(cache=True, forceobj=True)
def looplifted(n):
object()
res = 0
for i in range(n):
res = res + i
return res
@jit(cache=True, nopython=True)
def use_c_sin(x):
return c_sin(x)
@jit(cache=True, nopython=True)
def use_c_sin_nest1(x):
return use_c_sin(x)
@jit(cache=True, nopython=True)
def use_c_sin_nest2(x):
return use_c_sin_nest1(x)
@jit(cache=True, nopython=True)
def ambiguous_function(x):
return x + 2
renamed_function1 = ambiguous_function
@jit(cache=True, nopython=True)
def ambiguous_function(x):
return x + 6
renamed_function2 = ambiguous_function
def make_closure(x):
@jit(cache=True, nopython=True)
def closure(y):
return x + y
return closure
closure1 = make_closure(3)
closure2 = make_closure(5)
biggie = np.arange(10**6)
@jit(cache=True, nopython=True)
def use_big_array():
return biggie
Z = 1
# Exercise returning a record instance. This used to hardcode the dtype
# pointer's value in the bitcode.
packed_record_type = np.dtype([('a', np.int8), ('b', np.float64)])
aligned_record_type = np.dtype([('a', np.int8), ('b', np.float64)], align=True)
packed_arr = np.empty(2, dtype=packed_record_type)
for i in range(packed_arr.size):
packed_arr[i]['a'] = i + 1
packed_arr[i]['b'] = i + 42.5
aligned_arr = np.array(packed_arr, dtype=aligned_record_type)
@jit(cache=True, nopython=True)
def record_return(ary, i):
return ary[i]
class _TestModule(TestCase):
"""
Tests for functionality of this module's functions.
Note this does not define any "test_*" method, instead check_module()
should be called by hand.
"""
def check_module(self, mod):
self.assertPreciseEqual(mod.add_usecase(2, 3), 6)
self.assertPreciseEqual(mod.add_objmode_usecase(2, 3), 6)
self.assertPreciseEqual(mod.outer_uncached(3, 2), 2)
self.assertPreciseEqual(mod.outer(3, 2), 2)
self.assertPreciseEqual(mod.generated_usecase(3, 2), 1)
packed_rec = mod.record_return(mod.packed_arr, 1)
self.assertPreciseEqual(tuple(packed_rec), (2, 43.5))
aligned_rec = mod.record_return(mod.aligned_arr, 1)
self.assertPreciseEqual(tuple(aligned_rec), (2, 43.5))
# For 2.x
def runTest(self):
raise NotImplementedError
def self_test():
mod = sys.modules[__name__]
_TestModule().check_module(mod)
@jit(parallel=True, cache=True, nopython=True)
def parfor_usecase(ary):
return ary * ary + ary
|
py | 7dfef4c57503577a5f5be6afec52f33318e532c9 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2020 Alibaba Group Holding Limited. All Rights Reserved.
#
# 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.
#
import base64
import copy
import datetime
import glob
import hashlib
import inspect
import json
import logging
import numbers
import os
import pickle
import re
import shutil
import socket
import subprocess
import sys
import threading
import time
import uuid
import zipfile
from io import BytesIO
from pathlib import Path
from queue import Empty as EmptyQueue
from queue import Queue
from string import Template
import yaml
from google.protobuf.any_pb2 import Any
from graphscope.framework import utils
from graphscope.framework.errors import CompilationError
from graphscope.framework.graph_schema import GraphSchema
from graphscope.proto import attr_value_pb2
from graphscope.proto import data_types_pb2
from graphscope.proto import graph_def_pb2
from graphscope.proto import op_def_pb2
from graphscope.proto import types_pb2
from gscoordinator.io_utils import PipeWatcher
logger = logging.getLogger("graphscope")
# runtime workspace
try:
WORKSPACE = os.environ["GRAPHSCOPE_RUNTIME"]
except KeyError:
WORKSPACE = "/tmp/gs"
# COORDINATOR_HOME
# 1) get from gscoordinator python module, if failed,
# 2) infer from current directory
try:
import gscoordinator
COORDINATOR_HOME = os.path.abspath(os.path.join(gscoordinator.__file__, "..", ".."))
except ModuleNotFoundError:
COORDINATOR_HOME = os.path.abspath(os.path.join(__file__, "..", ".."))
# template directory for codegen
TEMPLATE_DIR = os.path.join(COORDINATOR_HOME, "gscoordinator", "template")
# builtin app resource
BUILTIN_APP_RESOURCE_PATH = os.path.join(
COORDINATOR_HOME, "gscoordinator", "builtin/app/builtin_app.gar"
)
# default config file in gar resource
DEFAULT_GS_CONFIG_FILE = ".gs_conf.yaml"
DEFAULT_GRAPHSCOPE_HOME = "/opt/graphscope"
# GRAPHSCOPE_HOME
# 1) get from environment variable `GRAPHSCOPE_HOME`, if not exist,
# 2) infer from COORDINATOR_HOME
GRAPHSCOPE_HOME = os.environ.get("GRAPHSCOPE_HOME", None)
# resolve from pip installed package
if GRAPHSCOPE_HOME is None:
if os.path.isdir(os.path.join(COORDINATOR_HOME, "graphscope.runtime")):
GRAPHSCOPE_HOME = os.path.join(COORDINATOR_HOME, "graphscope.runtime")
# find from DEFAULT_GRAPHSCOPE_HOME
if GRAPHSCOPE_HOME is None:
if os.path.isdir(DEFAULT_GRAPHSCOPE_HOME):
GRAPHSCOPE_HOME = DEFAULT_GRAPHSCOPE_HOME
# resolve from develop source tree
if GRAPHSCOPE_HOME is None:
GRAPHSCOPE_HOME = os.path.join(COORDINATOR_HOME, "..")
# ANALYTICAL_ENGINE_HOME
# 1) infer from GRAPHSCOPE_HOME
ANALYTICAL_ENGINE_HOME = os.path.join(GRAPHSCOPE_HOME)
ANALYTICAL_ENGINE_PATH = os.path.join(ANALYTICAL_ENGINE_HOME, "bin", "grape_engine")
if not os.path.isfile(ANALYTICAL_ENGINE_PATH):
# try get analytical engine from build dir
ANALYTICAL_ENGINE_HOME = os.path.join(GRAPHSCOPE_HOME, "analytical_engine")
ANALYTICAL_ENGINE_PATH = os.path.join(
ANALYTICAL_ENGINE_HOME, "build", "grape_engine"
)
# INTERACTIVE_ENGINE_SCRIPT
INTERAVTIVE_INSTANCE_TIMEOUT_SECONDS = 600 # 10 mins
INTERACTIVE_ENGINE_SCRIPT = os.path.join(GRAPHSCOPE_HOME, "bin", "giectl")
if not os.path.isfile(INTERACTIVE_ENGINE_SCRIPT):
INTERACTIVE_ENGINE_SCRIPT = os.path.join(
GRAPHSCOPE_HOME, "interactive_engine", "bin", "giectl"
)
# JAVA SDK related CONSTANTS
LLVM4JNI_HOME = os.environ.get("LLVM4JNI_HOME", None)
LLVM4JNI_USER_OUT_DIR_BASE = "user-llvm4jni-output"
PROCESSOR_MAIN_CLASS = "com.alibaba.graphscope.annotation.Main"
JAVA_CODEGNE_OUTPUT_PREFIX = "gs-ffi"
GRAPE_PROCESSOR_JAR = os.path.join(
GRAPHSCOPE_HOME, "lib", "grape-runtime-0.1-shaded.jar"
)
def get_timestamp():
now = datetime.datetime.now()
return datetime.datetime.timestamp(now)
def get_lib_path(app_dir, app_name):
lib_path = ""
if sys.platform == "linux" or sys.platform == "linux2":
lib_path = os.path.join(app_dir, "lib%s.so" % app_name)
elif sys.platform == "darwin":
lib_path = os.path.join(app_dir, "lib%s.dylib" % app_name)
else:
raise RuntimeError(f"Unsupported platform {sys.platform}")
return lib_path
def get_app_sha256(attr):
(
app_type,
app_header,
app_class,
vd_type,
md_type,
pregel_combine,
java_jar_path,
java_app_class,
) = _codegen_app_info(attr, DEFAULT_GS_CONFIG_FILE)
graph_header, graph_type = _codegen_graph_info(attr)
logger.info("Codegened graph type: %s, Graph header: %s", graph_type, graph_header)
if app_type == "cpp_pie":
return hashlib.sha256(
f"{app_type}.{app_class}.{graph_type}".encode("utf-8")
).hexdigest()
elif app_type == "java_pie":
s = hashlib.sha256()
# CAUTION!!!!!
# We believe jar_path.java_app_class can uniquely define one java app
s.update(f"{app_type}.{java_jar_path}.{java_app_class}".encode("utf-8"))
if types_pb2.GAR in attr:
s.update(attr[types_pb2.GAR].s)
return s.hexdigest()
else:
s = hashlib.sha256()
s.update(f"{app_type}.{app_class}.{graph_type}".encode("utf-8"))
if types_pb2.GAR in attr:
s.update(attr[types_pb2.GAR].s)
return s.hexdigest()
def get_graph_sha256(attr):
_, graph_class = _codegen_graph_info(attr)
return hashlib.sha256(graph_class.encode("utf-8")).hexdigest()
def compile_app(workspace: str, library_name, attr, engine_config: dict):
"""Compile an application.
Args:
workspace (str): working dir.
library_name (str): name of library
attr (`AttrValue`): All information needed to compile an app.
engine_config (dict): for options of NETWORKX
Returns:
str: Path of the built library.
str: Java jar path. For c++/python app, return None.
str: Directory containing generated java and jni code. For c++/python app, return None.
str: App type.
"""
app_dir = os.path.join(workspace, library_name)
os.makedirs(app_dir, exist_ok=True)
_extract_gar(app_dir, attr)
# codegen app and graph info
# vd_type and md_type is None in cpp_pie
(
app_type,
app_header,
app_class,
vd_type,
md_type,
pregel_combine,
java_jar_path,
java_app_class,
) = _codegen_app_info(attr, DEFAULT_GS_CONFIG_FILE)
logger.info(
"Codegened application type: %s, app header: %s, app_class: %s, vd_type: %s, md_type: %s, pregel_combine: %s, \
java_jar_path: %s, java_app_class: %s",
app_type,
app_header,
app_class,
str(vd_type),
str(md_type),
str(pregel_combine),
str(java_jar_path),
str(java_app_class),
)
graph_header, graph_type = _codegen_graph_info(attr)
logger.info("Codegened graph type: %s, Graph header: %s", graph_type, graph_header)
os.chdir(app_dir)
module_name = ""
# Output directory for java codegen
java_codegen_out_dir = ""
cmake_commands = [
"cmake",
".",
f"-DNETWORKX={engine_config['networkx']}",
f"-DCMAKE_PREFIX_PATH={GRAPHSCOPE_HOME}",
]
if app_type == "java_pie":
if not os.path.isfile(GRAPE_PROCESSOR_JAR):
raise RuntimeError("Grape runtime jar not found")
# for java need to run preprocess
java_codegen_out_dir = os.path.join(
workspace, "{}-{}".format(JAVA_CODEGNE_OUTPUT_PREFIX, library_name)
)
cmake_commands += [
"-DENABLE_JAVA_SDK=ON",
"-DJAVA_PIE_APP=ON",
"-DPRE_CP={}:{}".format(GRAPE_PROCESSOR_JAR, java_jar_path),
"-DPROCESSOR_MAIN_CLASS={}".format(PROCESSOR_MAIN_CLASS),
"-DJAR_PATH={}".format(java_jar_path),
"-DOUTPUT_DIR={}".format(java_codegen_out_dir),
]
# if run llvm4jni.sh not found, we just go ahead,since it is optional.
if LLVM4JNI_HOME and os.path.isfile(os.path.join(LLVM4JNI_HOME, "run.sh")):
llvm4jni_user_out_dir = os.path.join(
workspace, "{}-{}".format(LLVM4JNI_USER_OUT_DIR_BASE, library_name)
)
cmake_commands += [
"-DRUN_LLVM4JNI_SH={}".format(os.path.join(LLVM4JNI_HOME, "run.sh")),
"-DLLVM4JNI_OUTPUT={}".format(llvm4jni_user_out_dir),
"-DLIB_PATH={}".format(get_lib_path(app_dir, library_name)),
]
else:
logger.info(
"Skip running llvm4jni since env var LLVM4JNI_HOME not found or run.sh not found under LLVM4JNI_HOME"
)
logger.info(" ".join(cmake_commands))
elif app_type != "cpp_pie":
if app_type == "cython_pregel":
pxd_name = "pregel"
cmake_commands += ["-DCYTHON_PREGEL_APP=True"]
if pregel_combine:
cmake_commands += ["-DENABLE_PREGEL_COMBINE=True"]
else:
pxd_name = "pie"
cmake_commands += ["-DCYTHON_PIE_APP=True"]
# Copy pxd file and generate cc file from pyx
shutil.copyfile(
os.path.join(TEMPLATE_DIR, f"{pxd_name}.pxd.template"),
os.path.join(app_dir, f"{pxd_name}.pxd"),
)
# Assume the gar will have and only have one .pyx file
for pyx_file in glob.glob(app_dir + "/*.pyx"):
module_name = os.path.splitext(os.path.basename(pyx_file))[0]
cc_file = os.path.join(app_dir, module_name + ".cc")
subprocess.check_call(["cython", "-3", "--cplus", "-o", cc_file, pyx_file])
app_header = f"{module_name}.h"
# replace and generate cmakelist
cmakelists_file_tmp = os.path.join(TEMPLATE_DIR, "CMakeLists.template")
cmakelists_file = os.path.join(app_dir, "CMakeLists.txt")
with open(cmakelists_file_tmp, mode="r") as template:
content = template.read()
content = Template(content).safe_substitute(
_analytical_engine_home=ANALYTICAL_ENGINE_HOME,
_frame_name=library_name,
_vd_type=vd_type,
_md_type=md_type,
_graph_type=graph_type,
_graph_header=graph_header,
_module_name=module_name,
_app_type=app_class,
_app_header=app_header,
)
with open(cmakelists_file, mode="w") as f:
f.write(content)
# compile
logger.info("Building app ...")
cmake_process = subprocess.Popen(
cmake_commands,
env=os.environ.copy(),
universal_newlines=True,
encoding="utf-8",
stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE,
)
cmake_stderr_watcher = PipeWatcher(cmake_process.stderr, sys.stdout)
setattr(cmake_process, "stderr_watcher", cmake_stderr_watcher)
cmake_process.wait()
make_process = subprocess.Popen(
["make", "-j4"],
env=os.environ.copy(),
universal_newlines=True,
encoding="utf-8",
stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE,
)
make_stderr_watcher = PipeWatcher(make_process.stderr, sys.stdout)
setattr(make_process, "stderr_watcher", make_stderr_watcher)
make_process.wait()
lib_path = get_lib_path(app_dir, library_name)
if not os.path.isfile(lib_path):
raise CompilationError(f"Failed to compile app {app_class}")
return lib_path, java_jar_path, java_codegen_out_dir, app_type
def compile_graph_frame(workspace: str, library_name, attr: dict, engine_config: dict):
"""Compile an application.
Args:
workspace (str): Working dir.
library_name (str): name of library
attr (`AttrValue`): All information needed to compile a graph library.
engine_config (dict): for options of NETWORKX
Raises:
ValueError: When graph_type is not supported.
Returns:
str: Path of the built graph library.
None: For consistency with compiler_app.
None: For consistency with compile_app.
None: for consistency with compile_app.
"""
_, graph_class = _codegen_graph_info(attr)
logger.info("Codegened graph frame type: %s", graph_class)
library_dir = os.path.join(workspace, library_name)
os.makedirs(library_dir, exist_ok=True)
os.chdir(library_dir)
graph_type = attr[types_pb2.GRAPH_TYPE].graph_type
cmake_commands = [
"cmake",
".",
f"-DNETWORKX={engine_config['networkx']}",
f"-DCMAKE_PREFIX_PATH={GRAPHSCOPE_HOME}",
]
if graph_type == graph_def_pb2.ARROW_PROPERTY:
cmake_commands += ["-DPROPERTY_GRAPH_FRAME=True"]
elif graph_type in (
graph_def_pb2.ARROW_PROJECTED,
graph_def_pb2.DYNAMIC_PROJECTED,
graph_def_pb2.ARROW_FLATTENED,
):
cmake_commands += ["-DPROJECT_FRAME=True"]
else:
raise ValueError(f"Illegal graph type: {graph_type}")
# replace and generate cmakelist
cmakelists_file_tmp = os.path.join(TEMPLATE_DIR, "CMakeLists.template")
cmakelists_file = os.path.join(library_dir, "CMakeLists.txt")
with open(cmakelists_file_tmp, mode="r") as template:
content = template.read()
content = Template(content).safe_substitute(
_analytical_engine_home=ANALYTICAL_ENGINE_HOME,
_frame_name=library_name,
_graph_type=graph_class,
)
with open(cmakelists_file, mode="w") as f:
f.write(content)
# compile
logger.info("Building graph library ...")
cmake_process = subprocess.Popen(
cmake_commands,
env=os.environ.copy(),
universal_newlines=True,
encoding="utf-8",
stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE,
)
cmake_stderr_watcher = PipeWatcher(cmake_process.stderr, sys.stdout)
setattr(cmake_process, "stderr_watcher", cmake_stderr_watcher)
cmake_process.wait()
make_process = subprocess.Popen(
["make", "-j4"],
env=os.environ.copy(),
universal_newlines=True,
encoding="utf-8",
stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE,
)
make_stderr_watcher = PipeWatcher(make_process.stderr, sys.stdout)
setattr(make_process, "stderr_watcher", make_stderr_watcher)
make_process.wait()
lib_path = get_lib_path(library_dir, library_name)
if not os.path.isfile(lib_path):
raise CompilationError(f"Failed to compile graph {graph_class}")
return lib_path, None, None, None
def op_pre_process(op, op_result_pool, key_to_op, **kwargs): # noqa: C901
if op.op == types_pb2.REPORT_GRAPH:
return
if op.op == types_pb2.CREATE_GRAPH:
_pre_process_for_create_graph_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.ADD_LABELS:
_pre_process_for_add_labels_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.RUN_APP:
_pre_process_for_run_app_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.BIND_APP:
_pre_process_for_bind_app_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.PROJECT_GRAPH:
_pre_process_for_project_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.PROJECT_TO_SIMPLE:
_pre_process_for_project_to_simple_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.ADD_COLUMN:
_pre_process_for_add_column_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.UNLOAD_GRAPH:
_pre_process_for_unload_graph_op(op, op_result_pool, key_to_op, **kwargs)
if op.op in (
types_pb2.CONTEXT_TO_NUMPY,
types_pb2.CONTEXT_TO_DATAFRAME,
types_pb2.TO_VINEYARD_TENSOR,
types_pb2.TO_VINEYARD_DATAFRAME,
):
_pre_process_for_context_op(op, op_result_pool, key_to_op, **kwargs)
if op.op in (types_pb2.GRAPH_TO_NUMPY, types_pb2.GRAPH_TO_DATAFRAME):
_pre_process_for_output_graph_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.UNLOAD_APP:
_pre_process_for_unload_app_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.UNLOAD_CONTEXT:
_pre_process_for_unload_context_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.CREATE_INTERACTIVE_QUERY:
_pre_process_for_create_interactive_query_op(
op, op_result_pool, key_to_op, **kwargs
)
if op.op == types_pb2.GREMLIN_QUERY:
_pre_process_for_gremlin_query_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.FETCH_GREMLIN_RESULT:
_pre_process_for_fetch_gremlin_result(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.CLOSE_INTERACTIVE_QUERY:
_pre_process_for_close_interactive_query_op(
op, op_result_pool, key_to_op, **kwargs
)
if op.op == types_pb2.SUBGRAPH:
_pre_process_for_gremlin_to_subgraph_op(op, op_result_pool, key_to_op, **kwargs)
if op.op == types_pb2.CREATE_LEARNING_INSTANCE:
_pre_process_for_create_learning_graph_op(
op, op_result_pool, key_to_op, **kwargs
)
if op.op == types_pb2.CLOSE_LEARNING_INSTANCE:
_pre_process_for_close_learning_instance_op(
op, op_result_pool, key_to_op, **kwargs
)
if op.op == types_pb2.OUTPUT:
_pre_process_for_output_op(op, op_result_pool, key_to_op, **kwargs)
def _pre_process_for_create_graph_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) <= 1
if len(op.parents) == 1:
key_of_parent_op = op.parents[0]
parent_op = key_to_op[key_of_parent_op]
if parent_op.op == types_pb2.DATA_SOURCE:
for key, value in parent_op.attr.items():
op.attr[key].CopyFrom(value)
def _pre_process_for_add_labels_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 2
for key_of_parent_op in op.parents:
parent_op = key_to_op[key_of_parent_op]
if parent_op.op == types_pb2.DATA_SOURCE:
for key, value in parent_op.attr.items():
op.attr[key].CopyFrom(value)
else:
result = op_result_pool[key_of_parent_op]
op.attr[types_pb2.GRAPH_NAME].CopyFrom(
utils.s_to_attr(result.graph_def.key)
)
def _pre_process_for_close_interactive_query_op(
op, op_result_pool, key_to_op, **kwargs
):
assert len(op.parents) == 1
assert op.parents[0] in op_result_pool
def _pre_process_for_gremlin_to_subgraph_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
assert op.parents[0] in op_result_pool
def _pre_process_for_gremlin_query_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
assert op.parents[0] in op_result_pool
def _pre_process_for_fetch_gremlin_result(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
assert op.parents[0] in op_result_pool
def _pre_process_for_create_interactive_query_op(
op, op_result_pool, key_to_op, **kwargs
):
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
result = op_result_pool[key_of_parent_op]
assert result.graph_def.extension.Is(graph_def_pb2.VineyardInfoPb.DESCRIPTOR)
vy_info = graph_def_pb2.VineyardInfoPb()
result.graph_def.extension.Unpack(vy_info)
op.attr[types_pb2.VINEYARD_ID].CopyFrom(utils.i_to_attr(vy_info.vineyard_id))
op.attr[types_pb2.SCHEMA_PATH].CopyFrom(utils.s_to_attr(vy_info.schema_path))
def _pre_process_for_close_learning_instance_op(
op, op_result_pool, key_to_op, **kwargs
):
assert len(op.parents) == 1
assert op.parents[0] in op_result_pool
def _pre_process_for_create_learning_graph_op(op, op_result_pool, key_to_op, **kwargs):
from graphscope.learning.graph import Graph as LearningGraph
nodes = pickle.loads(op.attr[types_pb2.NODES].s)
edges = pickle.loads(op.attr[types_pb2.EDGES].s)
gen_labels = pickle.loads(op.attr[types_pb2.GLE_GEN_LABELS].s)
# get graph schema
op, op_result_pool, key_to_op
key_of_parent_op = op.parents[0]
result = op_result_pool[key_of_parent_op]
assert result.graph_def.extension.Is(graph_def_pb2.VineyardInfoPb.DESCRIPTOR)
schema = GraphSchema()
schema.from_graph_def(result.graph_def)
# get graph vineyard id
vy_info = graph_def_pb2.VineyardInfoPb()
result.graph_def.extension.Unpack(vy_info)
vineyard_id = vy_info.vineyard_id
# gle handle
engine_hosts = kwargs.pop("engine_hosts")
engine_config = kwargs.pop("engine_config")
handle = get_gl_handle(schema, vineyard_id, engine_hosts, engine_config)
config = LearningGraph.preprocess_args(handle, nodes, edges, gen_labels)
config = base64.b64encode(json.dumps(config).encode("utf-8")).decode("utf-8")
op.attr[types_pb2.VINEYARD_ID].CopyFrom(utils.i_to_attr(vineyard_id))
op.attr[types_pb2.GLE_HANDLE].CopyFrom(utils.s_to_attr(handle))
op.attr[types_pb2.GLE_CONFIG].CopyFrom(utils.s_to_attr(config))
# get `bind_app` runtime informarion in lazy mode
def _pre_process_for_bind_app_op(op, op_result_pool, key_to_op, **kwargs):
for key_of_parent_op in op.parents:
parent_op = key_to_op[key_of_parent_op]
if parent_op.op == types_pb2.CREATE_APP:
# app assets
op.attr[types_pb2.APP_ALGO].CopyFrom(parent_op.attr[types_pb2.APP_ALGO])
if types_pb2.GAR in parent_op.attr:
op.attr[types_pb2.GAR].CopyFrom(parent_op.attr[types_pb2.GAR])
else:
# get graph runtime information from results
result = op_result_pool[key_of_parent_op]
assert result.graph_def.extension.Is(
graph_def_pb2.VineyardInfoPb.DESCRIPTOR
)
vy_info = graph_def_pb2.VineyardInfoPb()
result.graph_def.extension.Unpack(vy_info)
op.attr[types_pb2.GRAPH_NAME].CopyFrom(
attr_value_pb2.AttrValue(s=result.graph_def.key.encode("utf-8"))
)
op.attr[types_pb2.GRAPH_TYPE].CopyFrom(
attr_value_pb2.AttrValue(graph_type=result.graph_def.graph_type)
)
op.attr[types_pb2.OID_TYPE].CopyFrom(
utils.s_to_attr(
utils.normalize_data_type_str(
utils.data_type_to_cpp(vy_info.oid_type)
)
)
)
op.attr[types_pb2.VID_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(vy_info.vid_type))
)
op.attr[types_pb2.V_DATA_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(vy_info.vdata_type))
)
op.attr[types_pb2.E_DATA_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(vy_info.edata_type))
)
# get `run_app` runtime informarion in lazy mode
def _pre_process_for_run_app_op(op, op_result_pool, key_to_op, **kwargs):
# run_app op has only one parent
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
parent_op = key_to_op[key_of_parent_op]
assert parent_op.op == types_pb2.BIND_APP
# set graph key
op.attr[types_pb2.GRAPH_NAME].CopyFrom(parent_op.attr[types_pb2.GRAPH_NAME])
result = op_result_pool[key_of_parent_op]
# set app key
op.attr[types_pb2.APP_NAME].CopyFrom(
attr_value_pb2.AttrValue(s=result.result.decode("utf-8").encode("utf-8"))
)
app_type = parent_op.attr[types_pb2.APP_ALGO].s.decode("utf-8")
if app_type == "java_app":
# For java app, we need lib path as an explicit arg.
param = Any()
lib_path = parent_op.attr[types_pb2.APP_LIBRARY_PATH].s.decode("utf-8")
param.Pack(data_types_pb2.StringValue(value=lib_path))
op.query_args.args.extend([param])
logger.info("Lib path {}".format(lib_path))
def _pre_process_for_unload_graph_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
result = op_result_pool[key_of_parent_op]
assert result.graph_def.extension.Is(graph_def_pb2.VineyardInfoPb.DESCRIPTOR)
vy_info = graph_def_pb2.VineyardInfoPb()
result.graph_def.extension.Unpack(vy_info)
op.attr[types_pb2.GRAPH_NAME].CopyFrom(utils.s_to_attr(result.graph_def.key))
op.attr[types_pb2.VINEYARD_ID].CopyFrom(utils.i_to_attr(vy_info.vineyard_id))
def _pre_process_for_unload_app_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
result = op_result_pool[key_of_parent_op]
op.attr[types_pb2.APP_NAME].CopyFrom(utils.s_to_attr(result.result.decode("utf-8")))
def _pre_process_for_unload_context_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
result = op_result_pool[key_of_parent_op]
parent_op_result = json.loads(result.result.decode("utf-8"))
context_key = parent_op_result["context_key"]
op.attr[types_pb2.CONTEXT_KEY].CopyFrom(
attr_value_pb2.AttrValue(s=context_key.encode("utf-8"))
)
def _pre_process_for_add_column_op(op, op_result_pool, key_to_op, **kwargs):
for key_of_parent_op in op.parents:
parent_op = key_to_op[key_of_parent_op]
if parent_op.op != types_pb2.RUN_APP:
# get graph information
r = op_result_pool[key_of_parent_op]
graph_name = r.graph_def.key
graph_type = r.graph_def.graph_type
schema = GraphSchema()
schema.from_graph_def(r.graph_def)
for key_of_parent_op in op.parents:
parent_op = key_to_op[key_of_parent_op]
if parent_op.op == types_pb2.RUN_APP:
selector = op.attr[types_pb2.SELECTOR].s.decode("utf-8")
r = op_result_pool[key_of_parent_op]
parent_op_result = json.loads(r.result.decode("utf-8"))
context_key = parent_op_result["context_key"]
context_type = parent_op_result["context_type"]
selector = _tranform_dataframe_selector(context_type, schema, selector)
op.attr[types_pb2.GRAPH_NAME].CopyFrom(utils.s_to_attr(graph_name))
op.attr[types_pb2.GRAPH_TYPE].CopyFrom(utils.graph_type_to_attr(graph_type))
op.attr[types_pb2.CONTEXT_KEY].CopyFrom(utils.s_to_attr(context_key))
op.attr[types_pb2.SELECTOR].CopyFrom(utils.s_to_attr(selector))
def _pre_process_for_context_op(op, op_result_pool, key_to_op, **kwargs):
def __backtrack_key_of_graph_op(key):
bfs_queue = Queue()
bfs_queue.put(key)
while not bfs_queue.empty():
next_op_key = bfs_queue.get()
if next_op_key in key_to_op:
next_op = key_to_op[next_op_key]
if next_op.op in (
types_pb2.CREATE_GRAPH,
types_pb2.ADD_LABELS,
types_pb2.TRANSFORM_GRAPH,
types_pb2.PROJECT_GRAPH,
types_pb2.PROJECT_TO_SIMPLE,
):
return next_op
for parent_key in next_op.parents:
bfs_queue.put(parent_key)
return None
assert len(op.parents) == 1
schema = None
key_of_parent_op = op.parents[0]
graph_op = __backtrack_key_of_graph_op(key_of_parent_op)
r = op_result_pool[key_of_parent_op]
# set context key
parent_op_result = json.loads(r.result.decode("utf-8"))
context_key = parent_op_result["context_key"]
context_type = parent_op_result["context_type"]
op.attr[types_pb2.CONTEXT_KEY].CopyFrom(
attr_value_pb2.AttrValue(s=context_key.encode("utf-8"))
)
r = op_result_pool[graph_op.key]
# transform selector
schema = GraphSchema()
schema.from_graph_def(r.graph_def)
selector = op.attr[types_pb2.SELECTOR].s.decode("utf-8")
if op.op in (types_pb2.CONTEXT_TO_DATAFRAME, types_pb2.TO_VINEYARD_DATAFRAME):
selector = _tranform_dataframe_selector(context_type, schema, selector)
else:
# to numpy
selector = _tranform_numpy_selector(context_type, schema, selector)
if selector is not None:
op.attr[types_pb2.SELECTOR].CopyFrom(
attr_value_pb2.AttrValue(s=selector.encode("utf-8"))
)
def _pre_process_for_output_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
parent_op = key_to_op[key_of_parent_op]
result = op_result_pool[key_of_parent_op]
if parent_op.output_type in (
types_pb2.VINEYARD_TENSOR,
types_pb2.VINEYARD_DATAFRAME,
):
# dependent to to_vineyard_dataframe
r = json.loads(result.result.decode("utf-8"))["object_id"]
op.attr[types_pb2.VINEYARD_ID].CopyFrom(utils.s_to_attr(r))
def _pre_process_for_output_graph_op(op, op_result_pool, key_to_op, **kwargs):
assert len(op.parents) == 1
key_of_parent_op = op.parents[0]
r = op_result_pool[key_of_parent_op]
schema = GraphSchema()
schema.from_graph_def(r.graph_def)
graph_name = r.graph_def.key
selector = op.attr[types_pb2.SELECTOR].s.decode("utf-8")
if op.op == types_pb2.GRAPH_TO_DATAFRAME:
selector = _tranform_dataframe_selector(
"labeled_vertex_property", schema, selector
)
else:
# to numpy
selector = _tranform_numpy_selector("labeled_vertex_property", schema, selector)
if selector is not None:
op.attr[types_pb2.SELECTOR].CopyFrom(
attr_value_pb2.AttrValue(s=selector.encode("utf-8"))
)
op.attr[types_pb2.GRAPH_NAME].CopyFrom(
attr_value_pb2.AttrValue(s=graph_name.encode("utf-8"))
)
def _pre_process_for_project_to_simple_op(op, op_result_pool, key_to_op, **kwargs):
# for nx graph
if op.attr[types_pb2.GRAPH_TYPE].graph_type in (
graph_def_pb2.DYNAMIC_PROJECTED,
graph_def_pb2.ARROW_FLATTENED,
):
return
assert len(op.parents) == 1
# get parent graph schema
key_of_parent_op = op.parents[0]
r = op_result_pool[key_of_parent_op]
schema = GraphSchema()
schema.from_graph_def(r.graph_def)
graph_name = r.graph_def.key
check_argument(
schema.vertex_label_num == 1,
"Cannot project to simple, vertex label number is not one.",
)
check_argument(
schema.edge_label_num == 1,
"Cannot project to simple, edge label number is not one.",
)
v_label = schema.vertex_labels[0]
e_label = schema.edge_labels[0]
relation = (v_label, v_label)
check_argument(
relation in schema.get_relationships(e_label),
f"Cannot project to simple, Graph doesn't contain such relationship: {v_label} -> {e_label} <- {v_label}.",
)
v_props = schema.get_vertex_properties(v_label)
e_props = schema.get_edge_properties(e_label)
check_argument(len(v_props) <= 1)
check_argument(len(e_props) <= 1)
v_label_id = schema.get_vertex_label_id(v_label)
e_label_id = schema.get_edge_label_id(e_label)
v_prop_id, vdata_type = (v_props[0].id, v_props[0].type) if v_props else (-1, None)
e_prop_id, edata_type = (e_props[0].id, e_props[0].type) if e_props else (-1, None)
oid_type = schema.oid_type
vid_type = schema.vid_type
op.attr[types_pb2.GRAPH_NAME].CopyFrom(
attr_value_pb2.AttrValue(s=graph_name.encode("utf-8"))
)
op.attr[types_pb2.GRAPH_TYPE].CopyFrom(
utils.graph_type_to_attr(graph_def_pb2.ARROW_PROJECTED)
)
op.attr[types_pb2.V_LABEL_ID].CopyFrom(utils.i_to_attr(v_label_id))
op.attr[types_pb2.V_PROP_ID].CopyFrom(utils.i_to_attr(v_prop_id))
op.attr[types_pb2.E_LABEL_ID].CopyFrom(utils.i_to_attr(e_label_id))
op.attr[types_pb2.E_PROP_ID].CopyFrom(utils.i_to_attr(e_prop_id))
op.attr[types_pb2.OID_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(oid_type))
)
op.attr[types_pb2.VID_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(vid_type))
)
op.attr[types_pb2.V_DATA_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(vdata_type))
)
op.attr[types_pb2.E_DATA_TYPE].CopyFrom(
utils.s_to_attr(utils.data_type_to_cpp(edata_type))
)
def _pre_process_for_project_op(op, op_result_pool, key_to_op, **kwargs):
def _get_all_v_props_id(schema, label):
props = schema.get_vertex_properties(label)
return [schema.get_vertex_property_id(label, prop.name) for prop in props]
def _get_all_e_props_id(schema, label):
props = schema.get_edge_properties(label)
return [schema.get_edge_property_id(label, prop.name) for prop in props]
assert len(op.parents) == 1
# get parent graph schema
key_of_parent_op = op.parents[0]
r = op_result_pool[key_of_parent_op]
schema = GraphSchema()
schema.from_graph_def(r.graph_def)
graph_name = r.graph_def.key
vertices = json.loads(op.attr[types_pb2.VERTEX_COLLECTIONS].s.decode("utf-8"))
edges = json.loads(op.attr[types_pb2.EDGE_COLLECTIONS].s.decode("utf-8"))
vertex_collections = {}
edge_collections = {}
for label, props in vertices.items():
label_id = schema.get_vertex_label_id(label)
if props is None:
vertex_collections[label_id] = _get_all_v_props_id(schema, label)
else:
vertex_collections[label_id] = sorted(
[schema.get_vertex_property_id(label, prop) for prop in props]
)
for label, props in edges.items():
relations = schema.get_relationships(label)
valid = False
for src, dst in relations:
if src in vertices and dst in vertices:
valid = True
break
if not valid:
raise ValueError("Cannot find a valid relation in given vertices and edges")
label_id = schema.get_edge_label_id(label)
if props is None:
edge_collections[label_id] = _get_all_e_props_id(schema, label)
else:
edge_collections[label_id] = sorted(
[schema.get_edge_property_id(label, prop) for prop in props]
)
vertex_collections = dict(sorted(vertex_collections.items()))
edge_collections = dict(sorted(edge_collections.items()))
# construct op attr
attr = attr_value_pb2.AttrValue()
v_attr = attr_value_pb2.NameAttrList()
e_attr = attr_value_pb2.NameAttrList()
for label, props in vertex_collections.items():
v_attr.attr[label].CopyFrom(utils.list_i_to_attr(props))
for label, props in edge_collections.items():
e_attr.attr[label].CopyFrom(utils.list_i_to_attr(props))
attr.list.func.extend([v_attr, e_attr])
op.attr[types_pb2.GRAPH_NAME].CopyFrom(
attr_value_pb2.AttrValue(s=graph_name.encode("utf-8"))
)
op.attr[types_pb2.ARROW_PROPERTY_DEFINITION].CopyFrom(attr)
del op.attr[types_pb2.VERTEX_COLLECTIONS]
del op.attr[types_pb2.EDGE_COLLECTIONS]
def _tranform_numpy_selector(context_type, schema, selector):
if context_type == "tensor":
selector = None
if context_type == "vertex_data":
selector = transform_vertex_data_selector(selector)
if context_type == "labeled_vertex_data":
selector = transform_labeled_vertex_data_selector(schema, selector)
if context_type == "vertex_property":
selector = transform_vertex_property_data_selector(selector)
if context_type == "labeled_vertex_property":
selector = transform_labeled_vertex_property_data_selector(schema, selector)
return selector
def _tranform_dataframe_selector(context_type, schema, selector):
selector = json.loads(selector)
if context_type == "tensor":
selector = {key: None for key, value in selector.items()}
if context_type == "vertex_data":
selector = {
key: transform_vertex_data_selector(value)
for key, value in selector.items()
}
if context_type == "labeled_vertex_data":
selector = {
key: transform_labeled_vertex_data_selector(schema, value)
for key, value in selector.items()
}
if context_type == "vertex_property":
selector = {
key: transform_vertex_property_data_selector(value)
for key, value in selector.items()
}
if context_type == "labeled_vertex_property":
selector = {
key: transform_labeled_vertex_property_data_selector(schema, value)
for key, value in selector.items()
}
return json.dumps(selector)
def _transform_vertex_data_v(selector):
if selector not in ("v.id", "v.data"):
raise SyntaxError("selector of v must be 'id' or 'data'")
return selector
def _transform_vertex_data_e(selector):
if selector not in ("e.src", "e.dst", "e.data"):
raise SyntaxError("selector of e must be 'src', 'dst' or 'data'")
return selector
def _transform_vertex_data_r(selector):
if selector != "r":
raise SyntaxError("selector of r must be 'r'")
return selector
def _transform_vertex_property_data_r(selector):
# The second part of selector or r is user defined name.
# So we will allow any str
return selector
def _transform_labeled_vertex_data_v(schema, label, prop):
label_id = schema.get_vertex_label_id(label)
if prop == "id":
return f"label{label_id}.{prop}"
else:
prop_id = schema.get_vertex_property_id(label, prop)
return f"label{label_id}.property{prop_id}"
def _transform_labeled_vertex_data_e(schema, label, prop):
label_id = schema.get_edge_label_id(label)
if prop in ("src", "dst"):
return f"label{label_id}.{prop}"
else:
prop_id = schema.get_vertex_property_id(label, prop)
return f"label{label_id}.property{prop_id}"
def _transform_labeled_vertex_data_r(schema, label):
label_id = schema.get_vertex_label_id(label)
return f"label{label_id}"
def _transform_labeled_vertex_property_data_r(schema, label, prop):
label_id = schema.get_vertex_label_id(label)
return f"label{label_id}.{prop}"
def transform_vertex_data_selector(selector):
"""Optional values:
vertex selector: 'v.id', 'v.data'
edge selector: 'e.src', 'e.dst', 'e.data'
result selector: 'r'
"""
if selector is None:
raise RuntimeError("selector cannot be None")
segments = selector.split(".")
if len(segments) > 2:
raise SyntaxError("Invalid selector: %s." % selector)
if segments[0] == "v":
selector = _transform_vertex_data_v(selector)
elif segments[0] == "e":
selector = _transform_vertex_data_e(selector)
elif segments[0] == "r":
selector = _transform_vertex_data_r(selector)
else:
raise SyntaxError(f"Invalid selector: {selector}, choose from v / e / r.")
return selector
def transform_vertex_property_data_selector(selector):
"""Optional values:
vertex selector: 'v.id', 'v.data'
edge selector: 'e.src', 'e.dst', 'e.data'
result selector format: 'r.y', y denotes property name.
"""
if selector is None:
raise RuntimeError("selector cannot be None")
segments = selector.split(".")
if len(segments) != 2:
raise SyntaxError(f"Invalid selector: {selector}")
if segments[0] == "v":
selector = _transform_vertex_data_v(selector)
elif segments[0] == "e":
selector = _transform_vertex_data_e(selector)
elif segments[0] == "r":
selector = _transform_vertex_property_data_r(selector)
else:
raise SyntaxError(f"Invalid selector: {selector}, choose from v / e / r.")
return selector
def transform_labeled_vertex_data_selector(schema, selector):
"""Formats: 'v:x.y/id', 'e:x.y/src/dst', 'r:label',
x denotes label name, y denotes property name.
Returned selector will change label name to 'label{id}', where id is x's id in labels.
And change property name to 'property{id}', where id is y's id in properties.
"""
if selector is None:
raise RuntimeError("selector cannot be None")
ret_type, segments = selector.split(":")
if ret_type not in ("v", "e", "r"):
raise SyntaxError(f"Invalid selector: {selector}")
segments = segments.split(".")
ret = ""
if ret_type == "v":
ret = _transform_labeled_vertex_data_v(schema, *segments)
elif ret_type == "e":
ret = _transform_labeled_vertex_data_e(schema, *segments)
elif ret_type == "r":
ret = _transform_labeled_vertex_data_r(schema, *segments)
return "{}:{}".format(ret_type, ret)
def transform_labeled_vertex_property_data_selector(schema, selector):
"""Formats: 'v:x.y/id', 'e:x.y/src/dst', 'r:x.y',
x denotes label name, y denotes property name.
Returned selector will change label name to 'label{id}', where id is x's id in labels.
And change property name to 'property{id}', where id is y's id in properties.
"""
if selector is None:
raise RuntimeError("selector cannot be None")
ret_type, segments = selector.split(":")
if ret_type not in ("v", "e", "r"):
raise SyntaxError(f"Invalid selector: {selector}")
segments = segments.split(".")
ret = ""
if ret_type == "v":
ret = _transform_labeled_vertex_data_v(schema, *segments)
elif ret_type == "e":
ret = _transform_labeled_vertex_data_e(schema, *segments)
elif ret_type == "r":
ret = _transform_labeled_vertex_property_data_r(schema, *segments)
return f"{ret_type}:{ret}"
def _extract_gar(app_dir: str, attr):
"""Extract gar to workspace
Args:
workspace (str): Working directory
attr (`AttrValue`): Optionally it can contains the bytes of gar.
"""
fp = BUILTIN_APP_RESOURCE_PATH # default is builtin app resources.
if types_pb2.GAR in attr:
# if gar sent via bytecode in attr, overwrite.
fp = BytesIO(attr[types_pb2.GAR].s)
with zipfile.ZipFile(fp, "r") as zip_ref:
zip_ref.extractall(app_dir)
def _codegen_app_info(attr, meta_file: str):
"""Codegen application by instanize the template specialization.
Args:
workspace (str): Working directory
meta_file (str): A yaml file that contains metas of all builtin app.
attr (`AttrValue`): For get algorithm name of app.
Raises:
KeyError: If the algorithm name doesn't exist in the `meta_file`
Returns:
type: app_type
app class: for fulfilling the CMakelists.
"""
fp = BUILTIN_APP_RESOURCE_PATH # default is builtin app resources.
if types_pb2.GAR in attr:
# if gar sent via bytecode in attr, overwrite.
fp = BytesIO(attr[types_pb2.GAR].s)
with zipfile.ZipFile(fp, "r") as zip_ref:
with zip_ref.open(meta_file, "r") as f:
config_yaml = yaml.safe_load(f)
algo = attr[types_pb2.APP_ALGO].s.decode("utf-8")
for app in config_yaml["app"]:
if app["algo"] == algo:
app_type = app["type"] # cpp_pie or cython_pregel or cython_pie, java_pie
if app_type == "cpp_pie":
return (
app_type,
app["src"],
f"{app['class_name']}<_GRAPH_TYPE>",
None,
None,
None,
None,
None,
)
if app_type in ("cython_pregel", "cython_pie"):
# cython app doesn't have c-header file
return (
app_type,
"",
"",
app["vd_type"],
app["md_type"],
app["pregel_combine"],
None,
None,
)
if app_type == "java_pie":
return (
app_type,
app["driver_header"], # cxx header
"{}<_GRAPH_TYPE>".format(app["class_name"]), # cxx class name
None, # vd_type,
None, # md_type
None, # pregel combine
app["java_jar_path"],
app["java_app_class"], # the running java app class
)
raise KeyError("Algorithm does not exist in the gar resource.")
# a mapping for classname to header file.
GRAPH_HEADER_MAP = {
graph_def_pb2.IMMUTABLE_EDGECUT: (
"grape::ImmutableEdgecutFragment",
"grape/fragment/immutable_edgecut_fragment.h",
),
graph_def_pb2.DYNAMIC_PROJECTED: (
"gs::DynamicProjectedFragment",
"core/fragment/dynamic_projected_fragment.h",
),
graph_def_pb2.ARROW_PROPERTY: (
"vineyard::ArrowFragment",
"vineyard/graph/fragment/arrow_fragment.h",
),
graph_def_pb2.ARROW_PROJECTED: (
"gs::ArrowProjectedFragment",
"core/fragment/arrow_projected_fragment.h",
),
graph_def_pb2.DYNAMIC_PROPERTY: (
"gs::DynamicFragment",
"core/fragment/dynamic_fragment.h",
),
graph_def_pb2.ARROW_FLATTENED: (
"gs::ArrowFlattenedFragment",
"core/fragment/arrow_flattened_fragment.h",
),
}
def _codegen_graph_info(attr):
graph_type = attr[types_pb2.GRAPH_TYPE].graph_type
graph_class, graph_header = GRAPH_HEADER_MAP[graph_type]
# graph_type is a literal of graph template in c++ side
if graph_class == "vineyard::ArrowFragment":
# in a format of full qualified name, e.g. vineyard::ArrowFragment<double, double>
graph_fqn = "{}<{},{}>".format(
graph_class,
attr[types_pb2.OID_TYPE].s.decode("utf-8"),
attr[types_pb2.VID_TYPE].s.decode("utf-8"),
)
elif graph_class in (
"gs::ArrowProjectedFragment",
"grape::ImmutableEdgecutFragment",
):
# in a format of gs::ArrowProjectedFragment<int64_t, uint32_t, double, double>
# or grape::ImmutableEdgecutFragment<int64_t, uint32_t, double, double>
graph_fqn = "{}<{},{},{},{}>".format(
graph_class,
attr[types_pb2.OID_TYPE].s.decode("utf-8"),
attr[types_pb2.VID_TYPE].s.decode("utf-8"),
attr[types_pb2.V_DATA_TYPE].s.decode("utf-8"),
attr[types_pb2.E_DATA_TYPE].s.decode("utf-8"),
)
elif graph_class == "gs::ArrowFlattenedFragment":
graph_fqn = "{}<{},{},{},{}>".format(
graph_class,
attr[types_pb2.OID_TYPE].s.decode("utf-8"),
attr[types_pb2.VID_TYPE].s.decode("utf-8"),
attr[types_pb2.V_DATA_TYPE].s.decode("utf-8"),
attr[types_pb2.E_DATA_TYPE].s.decode("utf-8"),
)
else:
# gs::DynamicProjectedFragment<double, double>
graph_fqn = "{}<{},{}>".format(
graph_class,
attr[types_pb2.V_DATA_TYPE].s.decode("utf-8"),
attr[types_pb2.E_DATA_TYPE].s.decode("utf-8"),
)
return graph_header, graph_fqn
def create_single_op_dag(op_type, config=None):
op_def = op_def_pb2.OpDef(op=op_type, key=uuid.uuid4().hex)
if config:
for k, v in config.items():
op_def.attr[k].CopyFrom(v)
dag = op_def_pb2.DagDef()
dag.op.extend([op_def])
return dag
def dump_as_json(schema, path):
out = {}
items = []
idx = 0
for i in range(len(schema.vertex_labels)):
vertex = {"id": idx, "label": schema.vertex_labels[i], "type": "VERTEX"}
vertex["propertyDefList"] = []
for j in range(len(schema.vertex_property_names[i].s)):
names = schema.vertex_property_names[i]
types = schema.vertex_property_types[i]
vertex["propertyDefList"].append(
{"id": j, "name": names.s[j], "data_type": types.s[j].upper()}
)
vertex["indexes"] = []
vertex["indexes"].append({"propertyNames": [names.s[0]]})
items.append(vertex)
idx += 1
for i in range(len(schema.edge_labels)):
edge = {"id": idx, "label": schema.edge_labels[i], "type": "EDGE"}
edge["propertyDefList"] = []
for j in range(len(schema.edge_property_names[i].s)):
names = schema.edge_property_names[i]
types = schema.edge_property_types[i]
edge["propertyDefList"].append(
{"id": j, "name": names.s[j], "data_type": types.s[j].upper()}
)
edge["rawRelationShips"] = []
edge["rawRelationShips"].append(
{"srcVertexLabel": "xx", "dstVertexLabel": "xx"}
)
idx += 1
items.append(edge)
out["types"] = items
out["partitionNum"] = 4
with open(path, "w") as fp:
json.dump(out, fp)
def dump_string(schema_string, path):
with open(path, "w") as fp:
fp.write(schema_string)
def parse_readable_memory(value):
value = str(value).strip()
num = value[:-2]
suffix = value[-2:]
try:
float(num)
except ValueError as e:
raise ValueError(f"Argument cannot be interpreted as a number: {value}") from e
if suffix not in ["Ki", "Mi", "Gi"]:
raise ValueError(f"Memory suffix must be one of 'Ki', 'Mi' and 'Gi': {value}")
return value
def parse_as_glog_level(log_level):
# log level in glog: INFO=1, DEBUG=10
# log level in python: DEBUG=10, INFO=20
if isinstance(log_level, str):
if log_level == "silent" or log_level == "SILENT":
log_level = -1
else:
log_level = getattr(logging, log_level.upper())
python_to_glog = {10: 10, 20: 1}
return python_to_glog.get(log_level, 1)
def str2bool(s):
if isinstance(s, bool):
return s
if s.lower() in ("yes", "true", "t", "y", "1"):
return True
return False
class ResolveMPICmdPrefix(object):
"""
Class for resolving prefix of mpi command.
Examples:
.. code:: ipython
>>> # openmpi found
>>> rmcp = ResolveMPICmdPrefix()
>>> (cmd, env) = rmcp.resolve(4, 'h1, h2, h3')
>>> cmd
['mpirun', '--allow-run-as-root',
'-n', '4', '-host', 'h1:2,h2:1,h3:1']
>>> env
{'OMPI_MCA_plm_rsh_agent': '/usr/bin/kube_ssh', # if /usr/bin/kube_ssh in $PATH
'OMPI_MCA_btl_vader_single_copy_mechanism': 'none',
'OMPI_MCA_orte_allowed_exit_without_sync': '1'}
>>> # if openmpi not found, change to mpich
>>> rmcp = ResolveMPICmdPrefix()
>>> (cmd, env) = rmcp.resolve(4, 'h1, h2, h3')
>>> cmd
['mpirun', '-n', '4', '-host', 'h1:2,h2:1,h3:1']
>>> env
{} # always empty
>>> # run without mpi on localhost when setting `num_workers` to 1
>>> rmcp = ResolveMPICmdPrefix()
>>> (cmd, env) = rmcp.resolve(1, 'localhost')
>>> cmd
[]
>>> env
{}
"""
_OPENMPI_RSH_AGENT = "OMPI_MCA_plm_rsh_agent"
_KUBE_SSH_EXEC = "kube_ssh"
def __init__(self, rsh_agent=False):
self._rsh_agent = rsh_agent
@staticmethod
def openmpi():
try:
subprocess.check_call(["ompi_info"], stdout=subprocess.DEVNULL)
except FileNotFoundError:
return False
return True
@staticmethod
def alloc(num_workers, hosts):
host_list = hosts.split(",")
host_list_len = len(host_list)
assert host_list_len != 0
host_to_proc_num = {}
if num_workers >= host_list_len:
quotient = num_workers / host_list_len
residue = num_workers % host_list_len
for host in host_list:
if residue > 0:
host_to_proc_num[host] = quotient + 1
residue -= 1
else:
host_to_proc_num[host] = quotient
else:
raise RuntimeError("The number of hosts less then num_workers")
for i in range(host_list_len):
host_list[i] = f"{host_list[i]}:{host_to_proc_num[host_list[i]]}"
return ",".join(host_list)
def resolve(self, num_workers, hosts):
cmd = []
env = {}
if num_workers == 1 and (hosts == "localhost" or hosts == "127.0.0.1"):
# run without mpi on localhost if workers num is 1
if shutil.which("ssh") is None:
# also need a fake ssh agent
env[self._OPENMPI_RSH_AGENT] = sys.executable
return cmd, env
if self.openmpi():
env["OMPI_MCA_btl_vader_single_copy_mechanism"] = "none"
env["OMPI_MCA_orte_allowed_exit_without_sync"] = "1"
# OMPI sends SIGCONT -> SIGTERM -> SIGKILL to the worker process,
# set the following MCA parameter to zero will emilinates the chances
# where the process dies before receiving the SIGTERM and do cleanup.
env["OMPI_MCA_odls_base_sigkill_timeout"] = "0"
if os.environ.get(self._OPENMPI_RSH_AGENT) is None:
rsh_agent_path = shutil.which(self._KUBE_SSH_EXEC)
if self._rsh_agent and rsh_agent_path is not None:
env[self._OPENMPI_RSH_AGENT] = rsh_agent_path
cmd.extend(
[
"mpirun",
"--allow-run-as-root",
]
)
else:
# ssh agent supported only
cmd.extend(["mpirun"])
cmd.extend(["-n", str(num_workers)])
cmd.extend(["-host", self.alloc(num_workers, hosts)])
logger.debug("Resolve mpi cmd prefix: %s", " ".join(cmd))
logger.debug("Resolve mpi env: %s", json.dumps(env))
return cmd, env
def get_gl_handle(schema, vineyard_id, engine_hosts, engine_config):
"""Dump a handler for GraphLearn for interaction.
Fields in :code:`schema` are:
+ the name of node type or edge type
+ whether the graph is weighted graph
+ whether the graph is labeled graph
+ the number of int attributes
+ the number of float attributes
+ the number of string attributes
An example of the graph handle:
.. code:: python
{
"server": "127.0.0.1:8888,127.0.0.1:8889",
"client_count": 1,
"vineyard_socket": "/var/run/vineyard.sock",
"vineyard_id": 13278328736,
"node_schema": [
"user:false:false:10:0:0",
"item:true:false:0:0:5"
],
"edge_schema": [
"user:click:item:true:false:0:0:0",
"user:buy:item:true:true:0:0:0",
"item:similar:item:false:false:10:0:0"
],
"node_attribute_types": {
"person": {
"age": "i",
"name": "s",
},
},
"edge_attribute_types": {
"knows": {
"weight": "f",
},
},
}
The handle can be decoded using:
.. code:: python
base64.b64decode(handle.encode('ascii')).decode('ascii')
Note that the ports are selected from a range :code:`(8000, 9000)`.
Args:
schema: The graph schema.
vineyard_id: The object id of graph stored in vineyard.
engine_hosts: A list of hosts for GraphScope engine workers.
engine_config: dict of config for GAE engine.
Returns:
str: Base64 encoded handle
"""
def group_property_types(props):
weighted, labeled, i, f, s, attr_types = "false", "false", 0, 0, 0, {}
for prop in props:
if prop.type in [graph_def_pb2.STRING]:
s += 1
attr_types[prop.name] = "s"
elif prop.type in (graph_def_pb2.FLOAT, graph_def_pb2.DOUBLE):
f += 1
attr_types[prop.name] = "f"
else:
i += 1
attr_types[prop.name] = "i"
if prop.name == "weight":
weighted = "true"
elif prop.name == "label":
labeled = "true"
return weighted, labeled, i, f, s, attr_types
node_schema, node_attribute_types = [], dict()
for label in schema.vertex_labels:
weighted, labeled, i, f, s, attr_types = group_property_types(
schema.get_vertex_properties(label)
)
node_schema.append(
"{}:{}:{}:{}:{}:{}".format(label, weighted, labeled, i, f, s)
)
node_attribute_types[label] = attr_types
edge_schema, edge_attribute_types = [], dict()
for label in schema.edge_labels:
weighted, labeled, i, f, s, attr_types = group_property_types(
schema.get_edge_properties(label)
)
for rel in schema.get_relationships(label):
edge_schema.append(
"{}:{}:{}:{}:{}:{}:{}:{}".format(
rel[0], label, rel[1], weighted, labeled, i, f, s
)
)
edge_attribute_types[label] = attr_types
handle = {
"hosts": engine_hosts,
"client_count": 1,
"vineyard_id": vineyard_id,
"vineyard_socket": engine_config["vineyard_socket"],
"node_schema": node_schema,
"edge_schema": edge_schema,
"node_attribute_types": node_attribute_types,
"edge_attribute_types": edge_attribute_types,
}
handle_json_string = json.dumps(handle)
return base64.b64encode(handle_json_string.encode("utf-8")).decode("utf-8")
# In Analytical engine, assume label ids of vertex entries are continuous
# from zero, and property ids of each label is also continuous from zero.
# When transform schema to Maxgraph style, we gather all property names and
# unique them, assign each name a id (index of the vector), then preserve a
# vector<int> for each label, stores mappings from original id to transformed
# id.
def to_maxgraph_schema(gsa_schema_json):
gsa_schema = json.loads(gsa_schema_json)
prop_set = set()
vertex_label_num = 0
for item in gsa_schema["types"]:
item["id"] = int(item["id"])
if item["type"] == "VERTEX":
vertex_label_num += 1
for prop in item["propertyDefList"]:
prop["id"] = int(prop["id"])
prop_set.add(prop["name"])
prop_list = sorted(list(prop_set))
mg_schema = copy.deepcopy(gsa_schema)
for item in mg_schema["types"]:
if item["propertyDefList"] == "":
item["propertyDefList"] = []
if item["type"] == "VERTEX":
for prop in item["propertyDefList"]:
prop["id"] = 1 + prop_list.index(prop["name"])
elif item["type"] == "EDGE":
item["id"] = vertex_label_num + item["id"]
for prop in item["propertyDefList"]:
prop["id"] = 1 + prop_list.index(prop["name"])
return json.dumps(mg_schema)
def check_argument(condition, message=None):
if not condition:
if message is None:
message = "in '%s'" % inspect.stack()[1].code_context[0]
raise ValueError(f"Check failed: {message}")
def find_java():
java_exec = ""
if "JAVA_HOME" in os.environ:
java_exec = os.path.expandvars("$JAVA_HOME/bin/java")
if not java_exec:
java_exec = shutil.which("java")
if not java_exec:
raise RuntimeError("java command not found.")
return java_exec
def get_java_version():
java_exec = find_java()
pattern = r'"(\d+\.\d+\.\d+).*"'
version = subprocess.check_output([java_exec, "-version"], stderr=subprocess.STDOUT)
return re.search(pattern, version.decode("utf-8")).groups()[0]
def check_gremlin_server_ready(endpoint):
from gremlin_python.driver.client import Client
if "MY_POD_NAME" in os.environ:
# inner kubernetes env
if endpoint == "localhost" or endpoint == "127.0.0.1":
# now, used in mac os with docker-desktop kubernetes cluster,
# which external ip is 'localhost' when service type is 'LoadBalancer'
return True
client = Client(f"ws://{endpoint}/gremlin", "g")
error_message = ""
begin_time = time.time()
while True:
try:
client.submit("g.V().limit(1)").all().result()
except Exception as e:
error_message = str(e)
else:
client.close()
return True
time.sleep(3)
if time.time() - begin_time > INTERAVTIVE_INSTANCE_TIMEOUT_SECONDS:
client.close()
raise TimeoutError(f"Gremlin check query failed: {error_message}")
|
py | 7dfef52717c55676af47645d0e17115684774087 | #! /usr/bin/env python3
# coding=utf-8
# This code is licensed under a non-commercial license.
import argparse
import csv
import json
import math
import numpy as np
import os
import time
import torch
import torch.nn.functional as F
import torch.optim
import torch.optim as optim
import torch.utils.data as data
from nltk.tokenize.treebank import TreebankWordDetokenizer
from torchtext import data as torchtext_data
from torchtext import datasets
from tqdm import tqdm, trange
from transformers import BertTokenizer, BertModel
from transformers import GPT2Tokenizer, GPT2LMHeadModel
from pplm_classification_head import ClassificationHead
torch.manual_seed(0)
np.random.seed(0)
EPSILON = 1e-10
example_sentence = "This is incredible! I love it, this is the best chicken I have ever had."
max_length_seq = 128
class Discriminator(torch.nn.Module):
"""Transformer encoder followed by a Classification Head"""
def __init__(
self,
class_size=None,
pretrained_model="gpt2-medium",
classifier_head=None,
cached_mode=False,
device='cpu'
):
super(Discriminator, self).__init__()
if pretrained_model.startswith("gpt2"):
self.tokenizer = GPT2Tokenizer.from_pretrained(pretrained_model)
self.encoder = GPT2LMHeadModel.from_pretrained(pretrained_model)
self.embed_size = self.encoder.transformer.config.hidden_size
elif pretrained_model.startswith("bert"):
self.tokenizer = BertTokenizer.from_pretrained(pretrained_model)
self.encoder = BertModel.from_pretrained(pretrained_model)
self.embed_size = self.encoder.config.hidden_size
elif ("finetune" in pretrained_model):
###presume using finetuned bert-base-uncased
self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
self.encoder = BertModel.from_pretrained(pretrained_model, output_hidden_states = False)
self.embed_size = self.encoder.config.hidden_size
if classifier_head:
self.classifier_head = classifier_head
else:
if not class_size:
raise ValueError("must specify class_size")
self.classifier_head = ClassificationHead(
class_size=class_size,
embed_size=self.embed_size
)
self.cached_mode = cached_mode
self.device = device
def get_classifier(self):
return self.classifier_head
def train_custom(self):
for param in self.encoder.parameters():
param.requires_grad = False
self.classifier_head.train()
def avg_representation(self, x):
mask = x.ne(0).unsqueeze(2).repeat(
1, 1, self.embed_size
).float().to(self.device).detach()
if hasattr(self.encoder, 'transformer'):
# for gpt2
hidden, _ = self.encoder.transformer(x)
else:
# for bert
hidden, _ = self.encoder(x)
masked_hidden = hidden * mask
avg_hidden = torch.sum(masked_hidden, dim=1) / (
torch.sum(mask, dim=1).detach() + EPSILON
)
return avg_hidden
def forward(self, x):
if self.cached_mode:
avg_hidden = x.to(self.device)
else:
avg_hidden = self.avg_representation(x.to(self.device))
logits = self.classifier_head(avg_hidden)
probs = F.log_softmax(logits, dim=-1)
return probs
def predict(self, input_sentence):
input_t = self.tokenizer.encode(input_sentence)
input_t = torch.tensor([input_t], dtype=torch.long, device=self.device)
if self.cached_mode:
input_t = self.avg_representation(input_t)
log_probs = self(input_t).data.cpu().numpy().flatten().tolist()
prob = [math.exp(log_prob) for log_prob in log_probs]
return prob
class Dataset(data.Dataset):
def __init__(self, X, y):
"""Reads source and target sequences from txt files."""
self.X = X
self.y = y
def __len__(self):
return len(self.X)
def __getitem__(self, index):
"""Returns one data pair (source and target)."""
data = {}
data["X"] = self.X[index]
data["y"] = self.y[index]
return data
def collate_fn(data):
def pad_sequences(sequences):
lengths = [len(seq) for seq in sequences]
padded_sequences = torch.zeros(
len(sequences),
max(lengths)
).long() # padding value = 0
for i, seq in enumerate(sequences):
end = lengths[i]
padded_sequences[i, :end] = seq[:end]
return padded_sequences, lengths
item_info = {}
for key in data[0].keys():
item_info[key] = [d[key] for d in data]
x_batch, _ = pad_sequences(item_info["X"])
y_batch = torch.tensor(item_info["y"], dtype=torch.long)
return x_batch, y_batch
def cached_collate_fn(data):
item_info = {}
for key in data[0].keys():
item_info[key] = [d[key] for d in data]
x_batch = torch.cat(item_info["X"], 0)
y_batch = torch.tensor(item_info["y"], dtype=torch.long)
return x_batch, y_batch
def train_epoch(data_loader, discriminator, optimizer,
epoch=0, log_interval=10, device='cpu'):
samples_so_far = 0
discriminator.train_custom()
for batch_idx, (input_t, target_t) in enumerate(data_loader):
input_t, target_t = input_t.to(device), target_t.to(device)
optimizer.zero_grad()
output_t = discriminator(input_t)
loss = F.nll_loss(output_t, target_t)
loss.backward(retain_graph=True)
optimizer.step()
samples_so_far += len(input_t)
if batch_idx % log_interval == 0:
print(
"Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}".format(
epoch + 1,
samples_so_far, len(data_loader.dataset),
100 * samples_so_far / len(data_loader.dataset), loss.item()
)
)
def evaluate_performance(data_loader, discriminator, device='cpu'):
discriminator.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for input_t, target_t in data_loader:
input_t, target_t = input_t.to(device), target_t.to(device)
output_t = discriminator(input_t)
# sum up batch loss
test_loss += F.nll_loss(output_t, target_t, reduction="sum").item()
# get the index of the max log-probability
pred_t = output_t.argmax(dim=1, keepdim=True)
correct += pred_t.eq(target_t.view_as(pred_t)).sum().item()
test_loss /= len(data_loader.dataset)
accuracy = correct / len(data_loader.dataset)
print(
"Performance on test set: "
"Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)".format(
test_loss, correct, len(data_loader.dataset),
100. * accuracy
)
)
return test_loss, accuracy
def predict(input_sentence, model, classes, cached=False, device='cpu'):
input_t = model.tokenizer.encode(input_sentence)
input_t = torch.tensor([input_t], dtype=torch.long, device=device)
if cached:
input_t = model.avg_representation(input_t)
log_probs = model(input_t).data.cpu().numpy().flatten().tolist()
# print("Input sentence:", input_sentence)
print("Predictions:", ", ".join(
"{}: {:.4f}".format(c, math.exp(log_prob)) for c, log_prob in
zip(classes, log_probs)
))
def get_cached_data_loader(dataset, batch_size, discriminator,
shuffle=False, device='cpu'):
data_loader = torch.utils.data.DataLoader(dataset=dataset,
batch_size=batch_size,
collate_fn=collate_fn)
xs = []
ys = []
for batch_idx, (x, y) in enumerate(tqdm(data_loader, ascii=True)):
with torch.no_grad():
x = x.to(device)
avg_rep = discriminator.avg_representation(x).cpu().detach()
avg_rep_list = torch.unbind(avg_rep.unsqueeze(1))
xs += avg_rep_list
ys += y.cpu().numpy().tolist()
data_loader = torch.utils.data.DataLoader(
dataset=Dataset(xs, ys),
batch_size=batch_size,
shuffle=shuffle,
collate_fn=cached_collate_fn)
return data_loader
def get_idx2class(dataset_fp, label_col = 1):
classes = set()
with open(dataset_fp) as f:
csv_reader = csv.reader(f, delimiter="\t")
for row in tqdm(csv_reader, ascii=True):
if row:
classes.add(row[label_col])
return sorted(classes)
def get_generic_dataset(dataset_fp, tokenizer, device,
idx2class=None, add_eos_token=False, label_col = 1, text_col = 0):
if not idx2class:
idx2class = get_idx2class(dataset_fp)
class2idx = {c: i for i, c in enumerate(idx2class)}
x = []
y = []
with open(dataset_fp) as f:
csv_reader = csv.reader(f, delimiter="\t")
for i, row in enumerate(tqdm(csv_reader, ascii=True)):
if row:
label = row[label_col]
text = row[text_col]
try:
seq = tokenizer.encode(text)
if (len(seq) < max_length_seq):
if add_eos_token:
seq = [50256] + seq
seq = torch.tensor(
seq,
device=device,
dtype=torch.long
)
else:
print(
"Line {} is longer than maximum length {}".format(
i, max_length_seq
))
continue
x.append(seq)
y.append(class2idx[label])
except:
print("Error tokenizing line {}, skipping it".format(i))
pass
return Dataset(x, y)
def train_discriminator(
dataset,
dataset_fp=None,
pretrained_model="gpt2-medium",
epochs=10,
learning_rate=0.0001,
batch_size=64,
log_interval=10,
save_model=False,
cached=False,
no_cuda=False,
output_fp='.'
):
device = "cuda" if torch.cuda.is_available() and not no_cuda else "cpu"
# If bert then do not add? Why?
add_eos_token = pretrained_model.startswith("gpt2")
if save_model:
if not os.path.exists(output_fp):
os.makedirs(output_fp)
classifier_head_meta_fp = os.path.join(
output_fp, "{}_classifier_head_meta.json".format(dataset)
)
classifier_head_fp_pattern = os.path.join(
output_fp, "{}_classifier_head_epoch".format(dataset) + "_{}.pt"
)
print("Preprocessing {} dataset...".format(dataset))
start = time.time()
if dataset == "SST":
idx2class = ["positive", "negative", "very positive", "very negative",
"neutral"]
class2idx = {c: i for i, c in enumerate(idx2class)}
discriminator = Discriminator(
class_size=len(idx2class),
pretrained_model=pretrained_model,
cached_mode=cached,
device=device
).to(device)
text = torchtext_data.Field()
label = torchtext_data.Field(sequential=False)
train_data, val_data, test_data = datasets.SST.splits(
text,
label,
fine_grained=True,
train_subtrees=True,
)
x = []
y = []
for i in trange(len(train_data), ascii=True):
seq = TreebankWordDetokenizer().detokenize(
vars(train_data[i])["text"]
)
seq = discriminator.tokenizer.encode(seq)
if add_eos_token:
seq = [50256] + seq
seq = torch.tensor(seq, device=device, dtype=torch.long)
x.append(seq)
y.append(class2idx[vars(train_data[i])["label"]])
train_dataset = Dataset(x, y)
test_x = []
test_y = []
for i in trange(len(test_data), ascii=True):
seq = TreebankWordDetokenizer().detokenize(
vars(test_data[i])["text"]
)
seq = discriminator.tokenizer.encode(seq)
if add_eos_token:
seq = [50256] + seq
seq = torch.tensor(seq, device=device, dtype=torch.long)
test_x.append(seq)
test_y.append(class2idx[vars(test_data[i])["label"]])
test_dataset = Dataset(test_x, test_y)
discriminator_meta = {
"class_size": len(idx2class),
"embed_size": discriminator.embed_size,
"pretrained_model": pretrained_model,
"class_vocab": class2idx,
"default_class": 2,
}
elif dataset == "clickbait":
idx2class = ["non_clickbait", "clickbait"]
class2idx = {c: i for i, c in enumerate(idx2class)}
discriminator = Discriminator(
class_size=len(idx2class),
pretrained_model=pretrained_model,
cached_mode=cached,
device=device
).to(device)
with open("datasets/clickbait/clickbait.txt") as f:
data = []
for i, line in enumerate(f):
try:
data.append(eval(line))
except:
print("Error evaluating line {}: {}".format(
i, line
))
continue
x = []
y = []
with open("datasets/clickbait/clickbait.txt") as f:
for i, line in enumerate(tqdm(f, ascii=True)):
try:
d = eval(line)
seq = discriminator.tokenizer.encode(d["text"])
if len(seq) < max_length_seq:
if add_eos_token:
seq = [50256] + seq
seq = torch.tensor(
seq, device=device, dtype=torch.long
)
else:
print("Line {} is longer than maximum length {}".format(
i, max_length_seq
))
continue
x.append(seq)
y.append(d["label"])
except:
print("Error evaluating / tokenizing"
" line {}, skipping it".format(i))
pass
full_dataset = Dataset(x, y)
train_size = int(0.9 * len(full_dataset))
test_size = len(full_dataset) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(
full_dataset, [train_size, test_size]
)
discriminator_meta = {
"class_size": len(idx2class),
"embed_size": discriminator.embed_size,
"pretrained_model": pretrained_model,
"class_vocab": class2idx,
"default_class": 1,
}
elif dataset == "toxic":
idx2class = ["non_toxic", "toxic"]
class2idx = {c: i for i, c in enumerate(idx2class)}
discriminator = Discriminator(
class_size=len(idx2class),
pretrained_model=pretrained_model,
cached_mode=cached,
device=device
).to(device)
x = []
y = []
with open("datasets/toxic/toxic_train.txt") as f:
for i, line in enumerate(tqdm(f, ascii=True)):
try:
d = eval(line)
seq = discriminator.tokenizer.encode(d["text"])
if len(seq) < max_length_seq:
if add_eos_token:
seq = [50256] + seq
seq = torch.tensor(
seq, device=device, dtype=torch.long
)
else:
print("Line {} is longer than maximum length {}".format(
i, max_length_seq
))
continue
x.append(seq)
y.append(int(np.sum(d["label"]) > 0))
except:
print("Error evaluating / tokenizing"
" line {}, skipping it".format(i))
pass
full_dataset = Dataset(x, y)
train_size = int(0.9 * len(full_dataset))
test_size = len(full_dataset) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(
full_dataset, [train_size, test_size]
)
discriminator_meta = {
"class_size": len(idx2class),
"embed_size": discriminator.embed_size,
"pretrained_model": pretrained_model,
"class_vocab": class2idx,
"default_class": 0,
}
else: # if dataset == "generic":
# This assumes the input dataset is a TSV with the following structure:
# class \t text
if dataset_fp is None:
raise ValueError("When generic dataset is selected, "
"dataset_fp needs to be specified aswell.")
idx2class = get_idx2class(dataset_fp)
discriminator = Discriminator(
class_size=len(idx2class),
pretrained_model=pretrained_model,
cached_mode=cached,
device=device
).to(device)
full_dataset = get_generic_dataset(
dataset_fp, discriminator.tokenizer, device,
idx2class=idx2class, add_eos_token=add_eos_token
)
train_size = int(0.9 * len(full_dataset))
test_size = len(full_dataset) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(
full_dataset,
[train_size, test_size]
)
discriminator_meta = {
"class_size": len(idx2class),
"embed_size": discriminator.embed_size,
"pretrained_model": pretrained_model,
"class_vocab": {c: i for i, c in enumerate(idx2class)},
"default_class": 0,
}
end = time.time()
print("Preprocessed {} data points".format(
len(train_dataset) + len(test_dataset))
)
print("Data preprocessing took: {:.3f}s".format(end - start))
if cached:
print("Building representation cache...")
start = time.time()
train_loader = get_cached_data_loader(
train_dataset, batch_size, discriminator,
shuffle=True, device=device
)
test_loader = get_cached_data_loader(
test_dataset, batch_size, discriminator, device=device
)
end = time.time()
print("Building representation cache took: {:.3f}s".format(end - start))
else:
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True,
collate_fn=collate_fn)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
collate_fn=collate_fn)
if save_model:
with open(classifier_head_meta_fp, "w") as meta_file:
json.dump(discriminator_meta, meta_file)
optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate)
test_losses = []
test_accuracies = []
for epoch in range(epochs):
start = time.time()
print("\nEpoch", epoch + 1)
train_epoch(
discriminator=discriminator,
data_loader=train_loader,
optimizer=optimizer,
epoch=epoch,
log_interval=log_interval,
device=device
)
test_loss, test_accuracy = evaluate_performance(
data_loader=test_loader,
discriminator=discriminator,
device=device
)
end = time.time()
print("Epoch took: {:.3f}s".format(end - start))
test_losses.append(test_loss)
test_accuracies.append(test_accuracy)
# print("\nExample prediction")
# predict(example_sentence, discriminator, idx2class,
# cached=cached, device=device)
if save_model:
# torch.save(discriminator.state_dict(),
# "{}_discriminator_{}.pt".format(
# args.dataset, epoch + 1
# ))
torch.save(discriminator.get_classifier().state_dict(),
classifier_head_fp_pattern.format(epoch + 1))
min_loss = float("inf")
min_loss_epoch = 0
max_acc = 0.0
max_acc_epoch = 0
print("Test performance per epoch")
print("epoch\tloss\tacc")
for e, (loss, acc) in enumerate(zip(test_losses, test_accuracies)):
print("{}\t{}\t{}".format(e + 1, loss, acc))
if loss < min_loss:
min_loss = loss
min_loss_epoch = e + 1
if acc > max_acc:
max_acc = acc
max_acc_epoch = e + 1
print("Min loss: {} - Epoch: {}".format(min_loss, min_loss_epoch))
print("Max acc: {} - Epoch: {}".format(max_acc, max_acc_epoch))
return discriminator, discriminator_meta
def load_classifier_head(weights_path, meta_path, device='cpu'):
with open(meta_path, 'r', encoding="utf8") as f:
meta_params = json.load(f)
classifier_head = ClassificationHead(
class_size=meta_params['class_size'],
embed_size=meta_params['embed_size']
).to(device)
classifier_head.load_state_dict(
torch.load(weights_path, map_location=device))
classifier_head.eval()
return classifier_head, meta_params
def load_discriminator(weights_path, meta_path, device='cpu'):
classifier_head, meta_param = load_classifier_head(
weights_path, meta_path, device
)
discriminator = Discriminator(
pretrained_model=meta_param['pretrained_model'],
classifier_head=classifier_head,
cached_mode=False,
device=device
)
return discriminator, meta_param
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Train a discriminator on top of GPT-2 representations")
parser.add_argument("--dataset", type=str, default="SST",
choices=("SST", "clickbait", "toxic", "generic"),
help="dataset to train the discriminator on."
"In case of generic, the dataset is expected"
"to be a TSBV file with structure: class \\t text")
parser.add_argument("--dataset_fp", type=str, default="",
help="File path of the dataset to use. "
"Needed only in case of generic datadset")
parser.add_argument("--pretrained_model", type=str, default="bert-base-uncased",
help="Pretrained model to use as encoder")
parser.add_argument("--epochs", type=int, default=3, metavar="N",
help="Number of training epochs")
parser.add_argument("--learning_rate", type=float, default=0.001,
help="Learnign rate")
parser.add_argument("--batch_size", type=int, default=64, metavar="N",
help="input batch size for training (default: 64)")
parser.add_argument("--log_interval", type=int, default=10, metavar="N",
help="how many batches to wait before logging training status")
parser.add_argument("--save_model", action="store_true",
help="whether to save the model")
parser.add_argument("--cached", action="store_true",
help="whether to cache the input representations")
parser.add_argument("--no_cuda", action="store_true",
help="use to turn off cuda")
parser.add_argument("--output_fp", default=".",
help="path to save the output to")
args = parser.parse_args()
train_discriminator(**(vars(args)))
|
py | 7dfef53d7fc74335cda1b39c5fd8cb411c41b42e | import numpy as np
class Node:
def __init__(self, X, y, depth):
self.left = None
self.right = None
self.min_error = np.inf
self.split_col_idx = None
self.num_rows = X.shape[0]
self.num_cols = X.shape[1]
self.split_val = None
self.depth = depth + 1
self.split(X, y)
def split(self, X, y):
if len(X) == 1:
return None
for i in range(self.num_cols):
self.calculate_split_idx(X[:, i], y, i)
if self.split_col_idx is None:
return None
X_left = X[self.filt]
y_left = y[self.filt]
self.left = Node(X_left, y_left, self.depth)
X_right = X[~self.filt]
y_right = y[~self.filt]
self.right = Node(X_right, y_right, self.depth)
def calculate_split_idx(self, X, y, var_idx):
for x in X:
filt = X <= x
y_left = y[filt]
y_right = y[~filt]
if len(y_right) == 0:
continue
error = ((y_left - y_left.mean()) ** 2).sum() + ((y_right - y_right.mean()) ** 2).sum()
if error < self.min_error:
self.min_error = error
self.split_col_idx = var_idx
self.split_val = x
self.filt = filt
class DecisionTree:
def __init__(self, max_depth=None):
self.max_depth = max_depth
def fit(self, X, y):
self.tree = Node(X, y, -1)
def predict(self, X):
pass
def score(self, X):
pass
|
py | 7dfef569f4d4fcc0049681ea92159812805e9a72 | """Test artefacts config tool."""
import unittest
import unittest.mock as mock
from pathlib import Path
from click.testing import CliRunner
from tests.test_utils import run_in_test_environment, UnitTestFixtures
from varats.data.discover_reports import initialize_reports
from varats.paper_mgmt.artefacts import Artefact
from varats.paper_mgmt.paper_config import get_paper_config, load_paper_config
from varats.plots.discover_plots import initialize_plots
from varats.table.table import Table
from varats.tables.discover_tables import initialize_tables
from varats.tools import driver_artefacts
from varats.utils.settings import vara_cfg
def _mock_table(table: Table):
(Path(table.table_kwargs["table_dir"]) / table.table_file_name()).touch()
class TestDriverArtefacts(unittest.TestCase):
"""Tests for the driver_artefacts module."""
@classmethod
def setUp(cls):
"""Setup artefacts file from yaml doc."""
initialize_reports()
initialize_tables()
initialize_plots()
@run_in_test_environment(UnitTestFixtures.PAPER_CONFIGS)
@mock.patch('varats.table.tables.build_table', side_effect=_mock_table)
# pylint: disable=unused-argument
def test_artefacts_generate(self, build_tables):
"""Test whether `vara-art generate` generates all expected files."""
# setup config
vara_cfg()['paper_config']['current_config'] = "test_artefacts_driver"
load_paper_config()
artefacts = get_paper_config().get_all_artefacts()
base_output_dir = Artefact.base_output_dir()
# vara-art generate
runner = CliRunner()
result = runner.invoke(driver_artefacts.main, ["generate"])
self.assertEqual(0, result.exit_code, result.exception)
# check that overview files are present
self.assertTrue((base_output_dir / "index.html").exists())
self.assertTrue((base_output_dir / "plot_matrix.html").exists())
# check that artefact files are present
for artefact in artefacts:
self.__check_artefact_files_present(artefact)
def __check_artefact_files_present(self, artefact: Artefact):
for file_info in artefact.get_artefact_file_infos():
self.assertTrue((artefact.output_dir / file_info.file_name).exists()
)
@run_in_test_environment(UnitTestFixtures.PAPER_CONFIGS)
def test_artefacts_list(self):
"""Test whether `vara-art list` produces expected output."""
# setup config
vara_cfg()['paper_config']['current_config'] = "test_artefacts_driver"
load_paper_config()
# vara-art generate
runner = CliRunner()
result = runner.invoke(driver_artefacts.main, ["list"])
self.assertEqual(0, result.exit_code, result.exception)
self.assertEqual(
"Paper Config Overview [plot]\nCorrelation Table [table]\n",
result.stdout
)
@run_in_test_environment(UnitTestFixtures.PAPER_CONFIGS)
def test_artefacts_show(self):
"""Test whether `vara-art show` produces expected output."""
# setup config
vara_cfg()['paper_config']['current_config'] = "test_artefacts_driver"
load_paper_config()
expected = r"""Artefact 'Paper Config Overview':
artefact_type: plot
artefact_type_version: 2
dry_run: false
file_type: png
name: Paper Config Overview
output_dir: .
plot_config: {}
plot_generator: pc-overview-plot
report_type: EmptyReport
view: false
"""
# vara-art generate
runner = CliRunner()
result = runner.invoke(
driver_artefacts.main, ["show", "Paper Config Overview"]
)
self.assertEqual(0, result.exit_code, result.exception)
self.assertEqual(expected, result.stdout)
|
py | 7dfef59113c201a18f6258f5cb85d63d9b8d529d | """ A PostController Module """
from masonite.controllers import Controller
from masonite.request import Request
from app.Post import Post
class PostController(Controller):
"""Class Docstring Description
"""
def __init__(self,request:Request):
self.request = request
def show(self):
"""Show a single resource listing
ex. Model.find('id')
Get().route("/show", PostController)
"""
id= self.request.param("id")
return Post.where("id",id).get()
def index(self):
"""Show several resource listings
ex. Model.all()
Get().route("/index", PostController)
"""
return Post.all()
def create(self):
"""Show form to create new resource listings
ex. Get().route("/create", PostController)
"""
title = self.request.input("title")
body = self.request.input("body")
body = Post.create({"title":title,"body":body})
return body
def update(self):
"""Edit an existing resource listing
ex. Post target to update new Model
Post().route("/update", PostController)
"""
id=self.request.param("id")
title = self.request.input("title")
body = self.request.input("body")
Post.where("id",id).update({"title":title,"body":body})
return Post.where("id",id).get()
def destroy(self):
"""Delete an existing resource listing
ex. Delete().route("/destroy", PostController)
"""
id=self.request.param("id")
title=self.request.input("title")
body = self.request.input("body")
post = Post.where("id",id).get()
Post.where("id",id).delete()
return post
|
py | 7dfef8c3e7baf1465b1b6673dbc5f8ae0c873ac0 | #!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "movierecommendation.settings")
try:
from django.core.management import execute_from_command_line
except ImportError:
# The above import may fail for some other reason. Ensure that the
# issue is really that Django is missing to avoid masking other
# exceptions on Python 2.
try:
import django
except ImportError:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
)
raise
execute_from_command_line(sys.argv)
|
py | 7dfef8d3718a638e5d60b3774bcc1116c06a00b1 | #!/usr/bin/env python3
# programming-with-guis
# Ex. 3.13
import os, pickle
from random import shuffle, randint
from guizero import App, Box, ListBox, Picture, PushButton, Text, Window, warn
def load_emojis():
emojis_dir = "./assets/emojis"
emojis = [os.path.join(emojis_dir, f) for f in os.listdir(emojis_dir) if os.path.isfile(os.path.join(emojis_dir, f))]
shuffle(emojis)
return emojis
def match_emoji(matched):
global in_a_row, player_num
if matched:
in_a_row += 1
result.value = "Correct"
result.text_color = "green"
players[player_num]["score"].value = int(players[player_num]["score"].value) + 1
if in_a_row == 3:
# add a bonus point
#players[player_num]["score"].value = int(players[player_num]["score"].value) + 1
#app.info("info", "Bonus points for 3 in a row!")
# add extra time
extra_time = randint(1,10)
timer.value = int(timer.value) + extra_time
result.value = "Extra " + str(extra_time) + " secs for 3 in a row!"
result.text_color = "blue"
in_a_row = 0
else:
result.value = "Incorrect"
result.text_color = "red"
players[player_num]["score"].value = int(players[player_num]["score"].value) - 1
if in_a_row > 0:
in_a_row -= 1
setup_round()
def setup_round():
pictures_box.visible = True
buttons_box.visible = True
players[player_num]["round"].value = int(players[player_num]["round"].value) + 1
emojis = load_emojis()
for picture in pictures:
picture.image = emojis.pop()
for button in buttons:
button.image = emojis.pop()
# set the command to be called and pass False, as these emoji wont be the matching ones
button.update_command(match_emoji, [False])
# choose a new emoji
matched_emoji = emojis.pop()
# select a number at random
random_picture = randint(0,8)
# change the image feature of the Picture with this index in the list of pictures to the new emoji
pictures[random_picture].image = matched_emoji
random_button = randint(0,8)
print(random_button)
# change the image feature of the PushButton with this index in the list of buttons to the new emoji
buttons[random_button].image = matched_emoji
# set the command to be called and pass True, as this is the matching emoji
buttons[random_button].update_command(match_emoji, [True])
def reset_game():
global player_num, in_a_row
in_a_row = 0
result.value = ""
players[player_num]["round"].value = "0"
players[player_num]["score"].value = "0"
setup_round()
timer.value = "20"
timer.repeat(1000, counter)
return
def counter():
global hi_scores, player_num
timer.value = int(timer.value) - 1
if int(timer.value) == 0:
timer.cancel(counter)
# add score to high scores
hi_scores.append(tuple((players[player_num]["label"].value, int(players[player_num]["score"].value))))
print(hi_scores)
save_hiscores()
# check who won
msg = "Game over!"
if int(players["1"]["round"].value) > 1 and int(players["2"]["round"].value) > 1:
print(players["1"]["score"].value, players["2"]["score"].value)
if int(players["1"]["score"].value) > int(players["2"]["score"].value):
msg = "Player 1 won!"
elif int(players["2"]["score"].value) > int(players["1"]["score"].value):
msg = "Player 2 won!"
else:
msg = "It's a draw"
result.value = msg
result.text_color = "black"
app.info("Info", msg)
# prompt = app.yesno(msg, "Do you want to play again?")
# if prompt == True:
# reset_game()
def start_game(num):
global player_num
player_num = num
player_name = app.question("Player " + num, "Enter your name")
if player_name is not None:
players[num]["label"].value = player_name
if num == "1":
spacer1.value = "<<<"
spacer2.value = " "
elif num == "2":
spacer1.value = " "
spacer2.value = ">>>"
else:
spacer1.value = " "
spacer2.value = " "
reset_game()
return
def load_hiscores():
if os.path.exists("hiscores.dat"):
fh = open('hiscores.dat', 'rb')
# deserialize data
hi_scores = pickle.load(fh)
fh.close()
else:
# populate with sample scores
hi_scores = [
("Carol Danvers", 10),
("Bruce Banner", 9),
("Thor Odinson", 8),
("Stephen Strange", 7),
("Wanda Maximoff", 6),
("Tony Stark", 5),
("Steve Rogers", 4),
("Peter Parker", 3),
("Scott Lang", 2),
("Natasha Romanoff", 1)
]
#print("load_hiscores:", hi_scores, type(hi_scores))
return hi_scores
def save_hiscores():
global hi_scores
#print("save_hiscores:", hi_scores)
fh = open('hiscores.dat', 'wb')
# serialize data
pickle.dump(hi_scores, fh)
fh.close()
return
# sort list of tuples by second element
# https://www.afternerd.com/blog/python-sort-list/#sort-tuples-second-element
def sort_hiscores(t):
return t[1]
def show_hiscores():
global hi_scores
hi_title = Text(wnd_hiscores, font=font_default, align="top", text="Top Players", size=18)
hi_box = Box(wnd_hiscores, align="top", layout="grid")
#hi_box.bg = "#CCCCCC"
scores = []
hi_scores.sort(reverse=True, key=sort_hiscores)
#print(hi_scores)
for x in range(0, len(hi_scores)):
if x < 20:
hi_line = Text(hi_box, font=font_default, text=str(x+1)+". ", align="left", grid=[0,x])
scores.append(hi_line)
for y in range(0, len(hi_scores[x])):
#print(x,y,hi_scores[x][y])
hi_line = Text(hi_box, font=font_default, text=hi_scores[x][y], align="left", grid=[y+1,x])
scores.append(hi_line)
else:
break
wnd_hiscores.show(wait=True) # modal window
return
def show_help():
wnd_help.show(wait=True) # modal window
return
# clear the contents since the high score list is appended each time the
# window is opened
def clear_hiscores_window():
for child in wnd_hiscores.children:
#print(child, type(child))
if hasattr(child, 'children'):
if child.children:
for grandchild in child.children:
grandchild.destroy()
child.destroy()
for child in wnd_hiscores.children:
child.destroy()
wnd_hiscores.hide()
return
def quit_app():
confirm = app.yesno("Confirm", "Do you want to exit?")
if confirm == True:
app.destroy()
app.display()
return
#---[ Main ]------------------------------------------------------------------
app = App("Emoji Match", layout="auto", width=700, height=480)
font_default = "JetBrains Mono"
in_a_row = 0
player_num = ""
# Set up High Score window
wnd_hiscores = Window(app, title="High Scores", bg="#DDDDDD", width=480, height=480, visible=False)
wnd_hiscores.when_closed = clear_hiscores_window
hi_scores = load_hiscores()
# Set up Help window
wnd_help = Window(app, title="Help", bg="#DDDDDD", width=700, height=480, visible=False)
help_box = Box(wnd_help, align="top", width="fill", layout="grid")
help_sec1_title = Text(help_box, font=font_default, text="How to play:", align="left", size=16, grid=[0,0])
help_sec1_line1 = Text(help_box, font=font_default, text=" ◉ Each player takes turns by clicking either the 'Player 1' or 'Player 2' buttons", align="left", grid=[0,1])
help_sec2_title = Text(help_box, font=font_default, text="Scoring:", align="left", size=16, grid=[0,2])
help_sec2_line1 = Text(help_box, font=font_default, text=" ◉ +1 pt for correct matches", align="left", grid=[0,3])
help_sec2_line2 = Text(help_box, font=font_default, text=" ◉ –1 pt for incorrect guesses", align="left", grid=[0,4])
help_sec2_line3 = Text(help_box, font=font_default, text=" ◉ For 3 matches in a row, extra time is added, randomly between 1-10 secs.", align="left", grid=[0,5])
# Set up scoreboard
scoreboard = Box(app, align="top", width="fill", layout="grid")
scoreboard.bg = "#C0C0C0"
players = {"1": {}, "2": {}}
players["1"]["label"] = Text(scoreboard, font=font_default, text="Player 1:", size=12, grid=[0,0,2,1])
spacer1 = Text(scoreboard, font=font_default, text=" ", color="#990000", size=20, width=20, grid=[2,0,1,3])
timer_lbl = Text(scoreboard, font=font_default, text="Timer: ", size=12, grid=[3,0])
spacer2 = Text(scoreboard, font=font_default, text=" ", color="#990000", size=20, width=20, grid=[4,0,1,3])
players["2"]["label"] = Text(scoreboard, font=font_default, text="Player 2:", size=12, grid=[5,0,2,1])
players["1"]["score_label"] = Text(scoreboard, font=font_default, text="Score", size=10, grid=[0,1])
players["1"]["round_label"] = Text(scoreboard, font=font_default, text="Round", size=10, grid=[1,1])
timer = Text(scoreboard, font=font_default, text="0", size=20, grid=[3,1])
players["2"]["score_label"] = Text(scoreboard, font=font_default, text="Score", size=10, grid=[5,1])
players["2"]["round_label"] = Text(scoreboard, font=font_default, text="Round", size=10, grid=[6,1])
players["1"]["score"] = Text(scoreboard, font=font_default, text="0", size=20, grid=[0,2])
players["1"]["round"] = Text(scoreboard, font=font_default, text="0", size=20, grid=[1,2])
players["2"]["score"] = Text(scoreboard, font=font_default, text="0", size=20, grid=[5,2])
players["2"]["round"] = Text(scoreboard, font=font_default, text="0", size=20, grid=[6,2])
# Set up game grids
game_box = Box(app, align="top", layout="grid")
result = Text(game_box, font=font_default, text="Ready?", size=24, grid=[0,0,3,1])
pictures_box = Box(game_box, layout="grid", grid=[0,1], visible=False)
spacer3 = Text(game_box, font=font_default, text=" ", width=10, grid=[1,1])
buttons_box = Box(game_box, layout="grid", grid=[2,1], visible=False)
instructions = Text(game_box, font=font_default, text="Choose an option:", size=10, grid=[0,2,3,1])
print("Font:", result.font)
buttons = []
pictures = []
for x in range(0,3):
for y in range(0,3):
picture = Picture(pictures_box, grid=[x,y])
pictures.append(picture)
button = PushButton(buttons_box, grid=[x,y])
buttons.append(button)
# Set up player controls
controls_box = Box(app, align="top", layout="grid")
btn_player1 = PushButton(controls_box, text="1 Player", image="./assets/btn_player1.gif", grid=[0,0], command=start_game, args=["1"])
btn_player2 = PushButton(controls_box, text="2 Players", image="./assets/btn_player2.gif", grid=[1,0], command=start_game, args=["2"])
btn_hiscores = PushButton(controls_box, text="High Scores", image="./assets/btn_hiscores.gif", grid=[2,0], command=show_hiscores)
btn_help = PushButton(controls_box, text="Help", image="./assets/btn_help.gif", grid=[3,0], command=show_help)
btn_exit = PushButton(controls_box, text="Exit", image="./assets/btn_exit.gif", grid=[4,0], command=quit_app)
app.display()
|
py | 7dfef8ed1e75c413aeb51dbbfcc5916d73adbd25 | # 345. Reverse Vowels of a String
# Write a function that takes a string as input and reverse only the vowels of a string.
# Example 1:
# Given s = "hello", return "holle".
# Example 2:
# Given s = "leetcode", return "leotcede".
# Note:
# The vowels does not include the letter "y".
class Solution(object):
def reverseVowels(self, s):
"""
:type s: str
:rtype: str
"""
v = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
vowels = []
indices = []
res = []
for i, ch in enumerate(s):
if ch in v:
vowels.append(ch)
indices.append(i)
else:
res.append(ch)
vowels.reverse()
for (i, x) in zip(indices, vowels):
res.insert(i, x)
return ''.join(res)
def reverseVowels(self, s):
"""
:type s: str
:rtype: str
"""
vowels = [i for i in range(len(s)) if s[i] in 'aeiouAEIOU']
s1 = list(s)
for i in range(len(vowels)//2):
s1[vowels[i]], s1[vowels[-i-1]] = s1[vowels[-i-1]], s1[vowels[i]]
return ''.join(s1)
|
py | 7dfef96492f549bfe515d20c866d4000c60cdc8a | """
矩阵的转置
Example 1:
Input: [[1,2,3],[4,5,6],[7,8,9]]
Output: [[1,4,7],[2,5,8],[3,6,9]]
Example 2:
Input: [[1,2,3],[4,5,6]]
Output: [[1,4],[2,5],[3,6]]
"""
class Solution():
def transpose(self, A):
R, C = len(A), len(A[0])
ans = [[None] * R for _ in range(C)]
for r, row in enumerate(A):
for c, val in enumerate(row):
ans[c][r] = val
return ans
if __name__ == '__main__':
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
s = Solution()
s.transpose(a) |
py | 7dfef98991c28ec4a6549046bd7d13bbbda4f9a9 |
# third-party
import numpy
# this package
from tuna import BaseClass
class UniformConvolution(object):
"""
A bounded uniform convolver
"""
def __init__(self, half_range, lower_bound, upper_bound):
"""
UniformConvolution constructor
:param:
- `half_range`: (-half_range, half_range) bounds the noise
- `lower_bound`: minimum value to allow in convolved arrays
- `upper_bound`: maximum value to allow in convolved array
"""
self.half_range = half_range
self.lower_bound = lower_bound
self.upper_bound = upper_bound
return
def __call__(self, vector):
"""
adds random noise, bounded by the lower and upper bound values
"""
tweak = numpy.random.uniform(low=-self.half_range,
high=self.half_range,
size=len(vector))
tweaked = vector + tweak
return tweaked.clip(self.lower_bound, self.upper_bound)
# end UniformConvolution
class GaussianConvolution(BaseClass):
"""
A Tweak that uses the Normal distribution
"""
def __init__(self, lower_bound, upper_bound,
location=0, scale=1, number_type=float,
scalar_multiplier=1):
"""
GaussianConvolution constructor
:param:
- `lower_bound`: minimum value to allow in tweaked arrays
- `upper_bound`: maximum value to allow in tweaked arrays
- `location`: Center of the distribution
- `scale`: Spread of the distribution
- `number_type`: type to cast random vector to
- `scalar_multiplier`: value to multiply tweak by
"""
super(GaussianConvolution, self).__init__()
self.lower_bound = lower_bound
self.upper_bound = upper_bound
self.location = location
self.scale = scale
self.number_type = number_type
self.scalar_multiplier = scalar_multiplier
return
def set_seed(self, seed):
"""
Sets the numpy random seed (for reproducibility)
"""
numpy.random.seed(seed)
return
def __call__(self, vector):
"""
Adds normally distributed random noise to the vector
Casts the tweak values to type specified by self.number_type
:return: vector + noise, bounded by upper and lower bounds
"""
tweak = numpy.random.normal(loc=self.location,
scale=self.scale,
size=len(vector)).astype(self.number_type)
tweaked = vector + self.scalar_multiplier * tweak
tweaked = tweaked.clip(self.lower_bound, self.upper_bound)
#self.logger.debug("Tweaked: {0}".format(tweaked))
return tweaked
# class GaussianConvolution
class GaussianConvolutionConstants(object):
__slots__ = ()
# options
lower_bound = 'lower_bound'
upper_bound = 'upper_bound'
location = 'location'
scale = 'scale'
number_type = 'number_type'
# defaults
location_default = 0
scale_default = 1
number_type_default='float'
class GaussianConvolutionBuilder(BaseClass):
"""
builds GaussianConvolutions
"""
def __init__(self, configuration, section):
"""
GaussianConvolutionBuilder constructor
:param:
- `configuration`: configuration map
- `section`: name of section with needed options
"""
self.configuration = configuration
self.section = section
self._product = None
return
@property
def product(self):
"""
A built GaussianConvolution
"""
if self._product is None:
config = self.configuration
constants = GaussianConvolutionConstants
num_type = config.get(section=self.section,
option=constants.number_type,
optional=False)
if num_type.lower().startswith('int'):
number_type = int
else:
number_type = float
location=config.get_float(section=self.section,
option=constants.location,
optional=True,
default=constants.location_default)
scale=config.get_float(section=self.section,
option=constants.scale,
optional=True,
default=constants.scale_default)
lower_bound=config.get_float(section=self.section,
option=constants.lower_bound)
upper_bound=config.get_float(section=self.section,
option=constants.upper_bound)
self._product = GaussianConvolution(location=location,
scale=scale,
lower_bound=lower_bound,
upper_bound=upper_bound,
number_type=number_type)
return self._product
class XYConvolution(BaseClass):
"""
A Tweak that uses the Normal distribution
"""
def __init__(self, x_min, x_max, y_min, y_max,
location=0, scale=1, number_type=float,
scalar_multiplier=1):
"""
GaussianConvolution constructor
:param:
- `x_min`: minimum value for x-value
- `x_max`: maximum value for x-value
- `y_min`: minimum value for y-value
- `y_max`: maximum value for y-value
- `location`: Center of the distribution
- `scale`: Spread of the distribution
- `number_type`: type to cast random vector to
- `scalar_multiplier`: value to multiply tweak by
"""
super(XYConvolution, self).__init__()
self.x_min = x_min
self.x_max = x_max
self.y_min = y_min
self.y_max = y_max
self.location = location
self.scale = scale
self.number_type = number_type
self.scalar_multiplier = scalar_multiplier
return
def set_seed(self, seed):
"""
Sets the numpy random seed (for reproducibility)
"""
numpy.random.seed(seed)
return
def __call__(self, vector):
"""
Adds normally distributed random noise to the vector
Casts the tweak values to type specified by self.number_type
:return: vector + noise, bounded by upper and lower bounds
"""
x = self.number_type(numpy.random.normal(loc=self.location,
scale=self.scale))
y = self.number_type(numpy.random.normal(loc=self.location,
scale=self.scale))
tweaked = vector + self.scalar_multiplier * numpy.array([x, y])
# this is done so that a non-square grid can be used
# so the 'clip' method won't work
x = max(self.x_min, tweaked[0])
x = min(self.x_max, x)
y = max(self.y_min, tweaked[1])
y = min(self.y_max, y)
tweaked = numpy.array([x, y])
#self.logger.debug("Tweaked: {0}".format(tweaked))
return tweaked
# class XYConvolution
class XYConvolutionConstants(object):
__slots__ = ()
# options
x_min = 'x_min'
x_max = 'x_max'
y_min = 'y_min'
y_max = 'y_max'
location = 'location'
scale = 'scale'
number_type = 'number_type'
# defaults
location_default = 0
scale_default = 1
number_type_default='float'
class XYConvolutionBuilder(BaseClass):
"""
builds XYConvolutions
"""
def __init__(self, configuration, section):
"""
XYConvolutionBuilder constructor
:param:
- `configuration`: configuration map
- `section`: name of section with needed options
"""
self.configuration = configuration
self.section = section
self._product = None
return
@property
def product(self):
"""
A built XYConvolution
"""
if self._product is None:
config = self.configuration
constants = XYConvolutionConstants
num_type = config.get(section=self.section,
option=constants.number_type,
optional=False)
if num_type.lower().startswith('int'):
number_type = int
else:
number_type = float
location=config.get_float(section=self.section,
option=constants.location,
optional=True,
default=constants.location_default)
scale=config.get_float(section=self.section,
option=constants.scale,
optional=True,
default=constants.scale_default)
x_min=config.get_float(section=self.section,
option=constants.x_min)
x_max=config.get_float(section=self.section,
option=constants.x_max)
y_min=config.get_float(section=self.section,
option=constants.y_min)
y_max=config.get_float(section=self.section,
option=constants.y_max)
self._product = XYConvolution(location=location,
scale=scale,
x_min=x_min,
x_max=x_max,
y_min=y_min,
y_max=y_max,
number_type=number_type)
return self._product
if __name__ == '__builtin__':
gaussian = GaussianConvolution(lower_bound=-100,
upper_bound=100)
candidate = numpy.array([5,6])
print gaussian(candidate)
# change the candidate, move the mean up, widen the distribution
gaussian.scale = 20
gaussian.location = 5
candidate = numpy.array([0, 1, 2])
gaussian.number_type = int
print gaussian(candidate)
# clip the values so it's right-skewed
gaussian.lower_bound = 5
gaussian.upper_bound = 100
print gaussian(candidate)
|
py | 7dfef98e56cac69ea2b77aea18ade1261cd41ddb | # -*- coding: utf-8 -*-
from FINDER_torch import FINDER
def main():
dqn = FINDER()
dqn.Train()
if __name__=="__main__":
main()
|
py | 7dfefa4ed8d5d6288d71b47e6f94e31d462598a2 | import pandas as pd # datu apstrāde
from termcolor import colored as cl # teksta izvade
def info(datne):
print(cl("\n\nInformācija par datni " + datne, 'green', attrs = ['reverse']))
# # importējam datus
# # df is saīsinajums no Data Frame,
# # Pandas bibliotēkas pamata datu struktūras
df = pd.read_csv(datne)
# # apskatīt pirmās 5 datu rindiņas
print(cl("\nPirmās 5 rindiņas", attrs = ['bold']))
print(df.head(5))
# # aplūkojam kolonnu nosaukumus
print(cl("\nKolonnu nosaukumi", attrs = ['bold']))
print(df.columns)
# # aplūkojam statistisku informāciju
print(cl("\nStatistika", attrs = ['bold']))
print(df.describe())
# print(cl("\nDatu tipi", attrs = ['bold']))
# aplūkojam datu tipus
print(cl(df.dtypes, attrs = ['bold']))
# # parāda, kur datos ir tukšas vērtības
print(cl("\nTukšas vērtības datos", attrs = ['bold']))
print(df.isnull().sum())
datne1 = 'dati/auto_simple.csv'
datne2 = 'dati/auto_imports.csv'
datne3 = 'dati/ss_auto.csv'
# parādām informāciju par datnē esošajiem datiem
info(datne3) |
py | 7dfefb8758d37060d0c258c9e4b764722cd95f5b | #!/usr/bin/env python3
# Tests check_format.py. This must be run in a context where the clang
# version and settings are compatible with the one in the Envoy
# docker. Normally this is run via check_format_test.sh, which
# executes it in under docker.
from __future__ import print_function
from run_command import runCommand
import argparse
import logging
import os
import shutil
import sys
import tempfile
curr_dir = os.path.dirname(os.path.realpath(__file__))
tools = os.path.dirname(curr_dir)
src = os.path.join(tools, 'testdata', 'check_format')
check_format = sys.executable + " " + os.path.join(curr_dir, 'check_format.py')
errors = 0
# Runs the 'check_format' operation, on the specified file, printing
# the comamnd run and the status code as well as the stdout, and returning
# all of that to the caller.
def runCheckFormat(operation, filename):
command = check_format + " " + operation + " " + filename
status, stdout, stderr = runCommand(command)
return (command, status, stdout + stderr)
def getInputFile(filename, extra_input_files=None):
files_to_copy = [filename]
if extra_input_files is not None:
files_to_copy.extend(extra_input_files)
for f in files_to_copy:
infile = os.path.join(src, f)
directory = os.path.dirname(f)
if not directory == '' and not os.path.isdir(directory):
os.makedirs(directory)
shutil.copyfile(infile, f)
return filename
# Attempts to fix file, returning a 4-tuple: the command, input file name,
# output filename, captured stdout as an array of lines, and the error status
# code.
def fixFileHelper(filename, extra_input_files=None):
command, status, stdout = runCheckFormat(
"fix", getInputFile(filename, extra_input_files=extra_input_files))
infile = os.path.join(src, filename)
return command, infile, filename, status, stdout
# Attempts to fix a file, returning the status code and the generated output.
# If the fix was successful, the diff is returned as a string-array. If the file
# was not fixable, the error-messages are returned as a string-array.
def fixFileExpectingSuccess(file, extra_input_files=None):
command, infile, outfile, status, stdout = fixFileHelper(file,
extra_input_files=extra_input_files)
if status != 0:
print("FAILED:")
emitStdoutAsError(stdout)
return 1
status, stdout, stderr = runCommand('diff ' + outfile + ' ' + infile + '.gold')
if status != 0:
print("FAILED:")
emitStdoutAsError(stdout + stderr)
return 1
return 0
def fixFileExpectingNoChange(file):
command, infile, outfile, status, stdout = fixFileHelper(file)
if status != 0:
return 1
status, stdout, stderr = runCommand('diff ' + outfile + ' ' + infile)
if status != 0:
logging.error(file + ': expected file to remain unchanged')
return 1
return 0
def emitStdoutAsError(stdout):
logging.error("\n".join(stdout))
def expectError(filename, status, stdout, expected_substring):
if status == 0:
logging.error("%s: Expected failure `%s`, but succeeded" % (filename, expected_substring))
return 1
for line in stdout:
if expected_substring in line:
return 0
logging.error("%s: Could not find '%s' in:\n" % (filename, expected_substring))
emitStdoutAsError(stdout)
return 1
def fixFileExpectingFailure(filename, expected_substring):
command, infile, outfile, status, stdout = fixFileHelper(filename)
return expectError(filename, status, stdout, expected_substring)
def checkFileExpectingError(filename, expected_substring, extra_input_files=None):
command, status, stdout = runCheckFormat(
"check", getInputFile(filename, extra_input_files=extra_input_files))
return expectError(filename, status, stdout, expected_substring)
def checkAndFixError(filename, expected_substring, extra_input_files=None):
errors = checkFileExpectingError(filename,
expected_substring,
extra_input_files=extra_input_files)
errors += fixFileExpectingSuccess(filename, extra_input_files=extra_input_files)
return errors
def checkToolNotFoundError():
# Temporarily change PATH to test the error about lack of external tools.
oldPath = os.environ["PATH"]
os.environ["PATH"] = "/sbin:/usr/sbin"
clang_format = os.getenv("CLANG_FORMAT", "clang-format-9")
# If CLANG_FORMAT points directly to the binary, skip this test.
if os.path.isfile(clang_format) and os.access(clang_format, os.X_OK):
os.environ["PATH"] = oldPath
return 0
errors = checkFileExpectingError("no_namespace_envoy.cc", "Command %s not found." % clang_format)
os.environ["PATH"] = oldPath
return errors
def checkUnfixableError(filename, expected_substring):
errors = checkFileExpectingError(filename, expected_substring)
errors += fixFileExpectingFailure(filename, expected_substring)
return errors
def checkFileExpectingOK(filename):
command, status, stdout = runCheckFormat("check", getInputFile(filename))
if status != 0:
logging.error("Expected %s to have no errors; status=%d, output:\n" % (filename, status))
emitStdoutAsError(stdout)
return status + fixFileExpectingNoChange(filename)
def runChecks():
errors = 0
# The following error is the error about unavailability of external tools.
errors += checkToolNotFoundError()
# The following errors can be detected but not fixed automatically.
errors += checkUnfixableError("no_namespace_envoy.cc",
"Unable to find Envoy namespace or NOLINT(namespace-envoy)")
errors += checkUnfixableError("mutex.cc", "Don't use <mutex> or <condition_variable*>")
errors += checkUnfixableError("condition_variable.cc",
"Don't use <mutex> or <condition_variable*>")
errors += checkUnfixableError("condition_variable_any.cc",
"Don't use <mutex> or <condition_variable*>")
errors += checkUnfixableError("shared_mutex.cc", "shared_mutex")
errors += checkUnfixableError("shared_mutex.cc", "shared_mutex")
real_time_inject_error = (
"Don't reference real-world time sources from production code; use injection")
errors += checkUnfixableError("real_time_source.cc", real_time_inject_error)
errors += checkUnfixableError("real_time_system.cc", real_time_inject_error)
errors += checkUnfixableError("system_clock.cc", real_time_inject_error)
errors += checkUnfixableError("steady_clock.cc", real_time_inject_error)
errors += checkUnfixableError(
"unpack_to.cc", "Don't use UnpackTo() directly, use MessageUtil::unpackTo() instead")
errors += checkUnfixableError("condvar_wait_for.cc", real_time_inject_error)
errors += checkUnfixableError("sleep.cc", real_time_inject_error)
errors += checkUnfixableError("std_atomic_free_functions.cc", "std::atomic_*")
errors += checkUnfixableError("std_get_time.cc", "std::get_time")
errors += checkUnfixableError("no_namespace_envoy.cc",
"Unable to find Envoy namespace or NOLINT(namespace-envoy)")
errors += checkUnfixableError("bazel_tools.BUILD", "unexpected @bazel_tools reference")
errors += checkUnfixableError("proto.BUILD", "unexpected direct external dependency on protobuf")
errors += checkUnfixableError("proto_deps.cc", "unexpected direct dependency on google.protobuf")
errors += checkUnfixableError("attribute_packed.cc", "Don't use __attribute__((packed))")
errors += checkUnfixableError("designated_initializers.cc", "Don't use designated initializers")
errors += checkUnfixableError("elvis_operator.cc", "Don't use the '?:' operator")
errors += checkUnfixableError("testing_test.cc",
"Don't use 'using testing::Test;, elaborate the type instead")
errors += checkUnfixableError(
"serialize_as_string.cc",
"Don't use MessageLite::SerializeAsString for generating deterministic serialization")
errors += checkUnfixableError(
"version_history.rst",
"Version history line malformed. Does not match VERSION_HISTORY_NEW_LINE_REGEX in "
"check_format.py")
errors += checkUnfixableError(
"counter_from_string.cc",
"Don't lookup stats by name at runtime; use StatName saved during construction")
errors += checkUnfixableError(
"gauge_from_string.cc",
"Don't lookup stats by name at runtime; use StatName saved during construction")
errors += checkUnfixableError(
"histogram_from_string.cc",
"Don't lookup stats by name at runtime; use StatName saved during construction")
errors += checkUnfixableError(
"regex.cc", "Don't use std::regex in code that handles untrusted input. Use RegexMatcher")
errors += checkUnfixableError(
"grpc_init.cc",
"Don't call grpc_init() or grpc_shutdown() directly, instantiate Grpc::GoogleGrpcContext. " +
"See #8282")
errors += checkUnfixableError(
"grpc_shutdown.cc",
"Don't call grpc_init() or grpc_shutdown() directly, instantiate Grpc::GoogleGrpcContext. " +
"See #8282")
errors += checkUnfixableError("clang_format_double_off.cc", "clang-format nested off")
errors += checkUnfixableError("clang_format_trailing_off.cc", "clang-format remains off")
errors += checkUnfixableError("clang_format_double_on.cc", "clang-format nested on")
errors += fixFileExpectingFailure(
"api/missing_package.proto",
"Unable to find package name for proto file: ./api/missing_package.proto")
errors += checkUnfixableError("proto_enum_mangling.cc",
"Don't use mangled Protobuf names for enum constants")
# The following files have errors that can be automatically fixed.
errors += checkAndFixError("over_enthusiastic_spaces.cc",
"./over_enthusiastic_spaces.cc:3: over-enthusiastic spaces")
errors += checkAndFixError("extra_enthusiastic_spaces.cc",
"./extra_enthusiastic_spaces.cc:3: over-enthusiastic spaces")
errors += checkAndFixError("angle_bracket_include.cc",
"envoy includes should not have angle brackets")
errors += checkAndFixError("proto_style.cc", "incorrect protobuf type reference")
errors += checkAndFixError("long_line.cc", "clang-format check failed")
errors += checkAndFixError("header_order.cc", "header_order.py check failed")
errors += checkAndFixError("clang_format_on.cc",
"./clang_format_on.cc:7: over-enthusiastic spaces")
# Validate that a missing license is added.
errors += checkAndFixError("license.BUILD", "envoy_build_fixer check failed")
# Validate that an incorrect license is replaced and reordered.
errors += checkAndFixError("update_license.BUILD", "envoy_build_fixer check failed")
# Validate that envoy_package() is added where there is an envoy_* rule occurring.
errors += checkAndFixError("add_envoy_package.BUILD", "envoy_build_fixer check failed")
# Validate that we don't add envoy_packag() when no envoy_* rule.
errors += checkFileExpectingOK("skip_envoy_package.BUILD")
# Validate that we clean up gratuitous blank lines.
errors += checkAndFixError("canonical_spacing.BUILD", "envoy_build_fixer check failed")
# Validate that unused loads are removed.
errors += checkAndFixError("remove_unused_loads.BUILD", "envoy_build_fixer check failed")
# Validate that API proto package deps are computed automagically.
errors += checkAndFixError("canonical_api_deps.BUILD",
"envoy_build_fixer check failed",
extra_input_files=[
"canonical_api_deps.cc", "canonical_api_deps.h",
"canonical_api_deps.other.cc"
])
errors += checkAndFixError("bad_envoy_build_sys_ref.BUILD", "Superfluous '@envoy//' prefix")
errors += checkAndFixError("proto_format.proto", "clang-format check failed")
errors += checkAndFixError(
"cpp_std.cc",
"term absl::make_unique< should be replaced with standard library term std::make_unique<")
errors += checkFileExpectingOK("real_time_source_override.cc")
errors += checkFileExpectingOK("time_system_wait_for.cc")
errors += checkFileExpectingOK("clang_format_off.cc")
return errors
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='tester for check_format.py.')
parser.add_argument('--log', choices=['INFO', 'WARN', 'ERROR'], default='INFO')
args = parser.parse_args()
logging.basicConfig(format='%(message)s', level=args.log)
# Now create a temp directory to copy the input files, so we can fix them
# without actually fixing our testdata. This requires chdiring to the temp
# directory, so it's annoying to comingle check-tests and fix-tests.
with tempfile.TemporaryDirectory() as tmp:
os.chdir(tmp)
errors = runChecks()
if errors != 0:
logging.error("%d FAILURES" % errors)
exit(1)
logging.warning("PASS")
|
py | 7dfefc6c37e04c56c10676abd66ef6dec58f45fa | #
# Copyright (C) 2021 Vaticle
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
#
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Iterator
from typedb.api.concept.type.type import Type, RemoteType
if TYPE_CHECKING:
from typedb.api.concept.type.relation_type import RelationType
from typedb.api.concept.type.thing_type import ThingType
from typedb.api.connection.transaction import TypeDBTransaction
class RoleType(Type, ABC):
def is_role_type(self) -> bool:
return True
@abstractmethod
def as_remote(self, transaction: "TypeDBTransaction") -> "RemoteRoleType":
pass
class RemoteRoleType(RemoteType, RoleType, ABC):
@abstractmethod
def get_supertype(self) -> RoleType:
pass
@abstractmethod
def get_supertypes(self) -> Iterator[RoleType]:
pass
@abstractmethod
def get_subtypes(self) -> Iterator[RoleType]:
pass
@abstractmethod
def get_relation_type(self) -> "RelationType":
pass
@abstractmethod
def get_relation_types(self) -> Iterator["RelationType"]:
pass
@abstractmethod
def get_players(self) -> Iterator["ThingType"]:
pass
|
py | 7dfefdefa653ba6eaee86af787a3832c649dcf0c | from typing import Optional
from typing import Text, Dict, Any
from tfx import types
from tfx.dsl.components.base import base_component
from tfx.dsl.components.base import executor_spec
from tfx.types.component_spec import ChannelParameter
from tfx.types.component_spec import ComponentSpec
from tfx.types.component_spec import ExecutionParameter
from tfx.types.standard_artifacts import Examples, Model, Schema, \
ModelEvaluation, ModelBlessing
from zenml.components.evaluator import constants
from zenml.components.evaluator import executor
class ZenMLEvaluatorSpec(ComponentSpec):
PARAMETERS = {constants.SOURCE: ExecutionParameter(type=Text),
constants.ARGS: ExecutionParameter(Text)}
INPUTS = {
constants.EXAMPLES: ChannelParameter(type=Examples),
constants.MODEL: ChannelParameter(type=Model, optional=True),
constants.BASELINE_MODEL: ChannelParameter(type=Model, optional=True),
constants.SCHEMA: ChannelParameter(type=Schema, optional=True)
}
OUTPUTS = {
constants.EVALUATION: ChannelParameter(type=ModelEvaluation),
constants.BLESSING: ChannelParameter(type=ModelBlessing,
optional=True),
}
class Evaluator(base_component.BaseComponent):
"""
A new adapted version version of the TFX Evaluator component.
In contrast to the original evaluator component, it utilizes a ZenML
EvaluatorStep and allows the model agnostic evaluation.
"""
SPEC_CLASS = ZenMLEvaluatorSpec
EXECUTOR_SPEC = executor_spec.ExecutorClassSpec(executor.Executor)
def __init__(
self,
source: Text,
source_args: Dict[Text, Any],
examples: types.Channel = None,
model: types.Channel = None,
baseline_model: Optional[types.Channel] = None,
blessing: Optional[types.Channel] = None,
output: Optional[types.Channel] = None,
schema: Optional[types.Channel] = None):
# Create the output artifact if not provided
evaluation = output or types.Channel(type=ModelEvaluation)
blessing = blessing or types.Channel(type=ModelBlessing)
# Create the spec
spec = ZenMLEvaluatorSpec(source=source,
args=source_args,
examples=examples,
model=model,
baseline_model=baseline_model,
blessing=blessing,
schema=schema,
evaluation=evaluation)
super(Evaluator, self).__init__(spec=spec)
|
py | 7dfefedbf718ba160caa9fbddffda8019a16268a | # coding: utf-8
"""
Kubernetes
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501
OpenAPI spec version: release-1.16
Generated by: https://openapi-generator.tech
"""
import pprint
import re # noqa: F401
import six
class V1ReplicationControllerCondition(object):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
openapi_types = {
'last_transition_time': 'datetime',
'message': 'str',
'reason': 'str',
'status': 'str',
'type': 'str'
}
attribute_map = {
'last_transition_time': 'lastTransitionTime',
'message': 'message',
'reason': 'reason',
'status': 'status',
'type': 'type'
}
def __init__(self, last_transition_time=None, message=None, reason=None, status=None, type=None): # noqa: E501
"""V1ReplicationControllerCondition - a model defined in OpenAPI""" # noqa: E501
self._last_transition_time = None
self._message = None
self._reason = None
self._status = None
self._type = None
self.discriminator = None
if last_transition_time is not None:
self.last_transition_time = last_transition_time
if message is not None:
self.message = message
if reason is not None:
self.reason = reason
self.status = status
self.type = type
@property
def last_transition_time(self):
"""Gets the last_transition_time of this V1ReplicationControllerCondition. # noqa: E501
The last time the condition transitioned from one status to another. # noqa: E501
:return: The last_transition_time of this V1ReplicationControllerCondition. # noqa: E501
:rtype: datetime
"""
return self._last_transition_time
@last_transition_time.setter
def last_transition_time(self, last_transition_time):
"""Sets the last_transition_time of this V1ReplicationControllerCondition.
The last time the condition transitioned from one status to another. # noqa: E501
:param last_transition_time: The last_transition_time of this V1ReplicationControllerCondition. # noqa: E501
:type: datetime
"""
self._last_transition_time = last_transition_time
@property
def message(self):
"""Gets the message of this V1ReplicationControllerCondition. # noqa: E501
A human readable message indicating details about the transition. # noqa: E501
:return: The message of this V1ReplicationControllerCondition. # noqa: E501
:rtype: str
"""
return self._message
@message.setter
def message(self, message):
"""Sets the message of this V1ReplicationControllerCondition.
A human readable message indicating details about the transition. # noqa: E501
:param message: The message of this V1ReplicationControllerCondition. # noqa: E501
:type: str
"""
self._message = message
@property
def reason(self):
"""Gets the reason of this V1ReplicationControllerCondition. # noqa: E501
The reason for the condition's last transition. # noqa: E501
:return: The reason of this V1ReplicationControllerCondition. # noqa: E501
:rtype: str
"""
return self._reason
@reason.setter
def reason(self, reason):
"""Sets the reason of this V1ReplicationControllerCondition.
The reason for the condition's last transition. # noqa: E501
:param reason: The reason of this V1ReplicationControllerCondition. # noqa: E501
:type: str
"""
self._reason = reason
@property
def status(self):
"""Gets the status of this V1ReplicationControllerCondition. # noqa: E501
Status of the condition, one of True, False, Unknown. # noqa: E501
:return: The status of this V1ReplicationControllerCondition. # noqa: E501
:rtype: str
"""
return self._status
@status.setter
def status(self, status):
"""Sets the status of this V1ReplicationControllerCondition.
Status of the condition, one of True, False, Unknown. # noqa: E501
:param status: The status of this V1ReplicationControllerCondition. # noqa: E501
:type: str
"""
if status is None:
raise ValueError("Invalid value for `status`, must not be `None`") # noqa: E501
self._status = status
@property
def type(self):
"""Gets the type of this V1ReplicationControllerCondition. # noqa: E501
Type of replication controller condition. # noqa: E501
:return: The type of this V1ReplicationControllerCondition. # noqa: E501
:rtype: str
"""
return self._type
@type.setter
def type(self, type):
"""Sets the type of this V1ReplicationControllerCondition.
Type of replication controller condition. # noqa: E501
:param type: The type of this V1ReplicationControllerCondition. # noqa: E501
:type: str
"""
if type is None:
raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501
self._type = type
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, V1ReplicationControllerCondition):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
|
py | 7dff0156ae2efb16e0ced6fed76fed4cb79a2d0d | # GENERATED BY KOMAND SDK - DO NOT EDIT
import insightconnect_plugin_runtime
import json
class Component:
DESCRIPTION = "Update an existing ServiceNow CI record"
class Input:
SYSTEM_ID = "system_id"
TABLE = "table"
UPDATE_DATA = "update_data"
class Output:
SUCCESS = "success"
class UpdateCiInput(insightconnect_plugin_runtime.Input):
schema = json.loads("""
{
"type": "object",
"title": "Variables",
"properties": {
"system_id": {
"type": "string",
"title": "System ID",
"description": "System ID of the CI record to update",
"order": 2
},
"table": {
"type": "string",
"title": "Table",
"description": "The ServiceNow table where the CI record will be updated",
"order": 1
},
"update_data": {
"type": "object",
"title": "Update Data",
"description": "JSON object containing the fields and values to perform a CI update",
"order": 3
}
},
"required": [
"system_id",
"table",
"update_data"
]
}
""")
def __init__(self):
super(self.__class__, self).__init__(self.schema)
class UpdateCiOutput(insightconnect_plugin_runtime.Output):
schema = json.loads("""
{
"type": "object",
"title": "Variables",
"properties": {
"success": {
"type": "boolean",
"title": "Success",
"description": "True if the update was successful",
"order": 1
}
},
"required": [
"success"
]
}
""")
def __init__(self):
super(self.__class__, self).__init__(self.schema)
|
py | 7dff01d9441c731cdc011f67431c8b46da539e2c | import numpy as np
import keras
import tensorflow as tf
from keras.models import Model, load_model
import keras.backend as K
from model import get_card_model
import os, pickle
from model import *
from datetime import date
l_exp = [0.00018, 0.00033, 0.00050, 0.00054, 0.00062, 0.00067, 0.00075, 0.00085, 0.00103, 0.00138, 0.00145, 0.00156, 0.00170, 0.00224, 0.00224, 0.00229, 0.00259, 0.00264, 0.00264, 0.00266, 0.00290, 0.00290, 0.00373, 0.00392, 0.00410, 0.00425, 0.00438, 0.00445, 0.00466, 0.00474, 0.00492, 0.00503, 0.00503, 0.00508, 0.00531, 0.00532, 0.00550, 0.00552, 0.00570, 0.00584, 0.00642, 0.00642, 0.00679, 0.00692, 0.00693, 0.00697, 0.00719, 0.00733, 0.00735, 0.00740, 0.00743, 0.00749, 0.00782, 0.00790, 0.00810, 0.00812, 0.00828, 0.00856, 0.00870, 0.00876, 0.00884, 0.00889, 0.00922, 0.00933, 0.00987, 0.00989, 0.00999, 0.01031, 0.01043, 0.01090, 0.01115, 0.01127, 0.01131, 0.01134, 0.01171, 0.01187, 0.01189, 0.01190, 0.01199, 0.01228, 0.01234, 0.01255, 0.01259, 0.01266, 0.01275, 0.01305, 0.01326, 0.01326, 0.01398, 0.01437, 0.01456, 0.01461, 0.01473, 0.01479, 0.01496, 0.01503, 0.01517, 0.01537, 0.01542, 0.01567, 0.01579, 0.01588, 0.01591, 0.01597, 0.01631, 0.01639, 0.01663, 0.01682, 0.01690, 0.01712, 0.01714, 0.01717, 0.01766, 0.01774, 0.01790, 0.01818, 0.01820, 0.01822, 0.01835, 0.01835, 0.01842, 0.01848, 0.01852, 0.01893, 0.01913, 0.01914, 0.01944, 0.01963, 0.01971, 0.02006, 0.02011, 0.02015, 0.02033, 0.02042, 0.02104, 0.02111, 0.02121, 0.02137, 0.02141, 0.02187, 0.02194, 0.02203, 0.02224, 0.02247, 0.02278, 0.02286, 0.02336, 0.02344, 0.02351, 0.02364, 0.02365, 0.02381, 0.02381, 0.02455, 0.02460, 0.02463, 0.02466, 0.02470, 0.02476, 0.02490, 0.02498, 0.02520, 0.02529, 0.02551, 0.02595, 0.02618, 0.02634, 0.02646, 0.02653, 0.02654, 0.02656, 0.02658, 0.02682, 0.02752, 0.02757, 0.02764, 0.02769, 0.02770, 0.02809, 0.02817, 0.02825, 0.02832, 0.02835, 0.02836, 0.02838, 0.02890, 0.02897, 0.02898, 0.02900, 0.02933, 0.02972, 0.02973, 0.02995, 0.02999, 0.03025, 0.03026, 0.03034, 0.03072, 0.03077, 0.03110, 0.03115, 0.03142, 0.03148, 0.03169, 0.03182, 0.03211, 0.03215, 0.03220, 0.03227, 0.03250, 0.03276, 0.03288, 0.03290, 0.03318, 0.03319, 0.03334, 0.03344, 0.03381, 0.03408, 0.03444, 0.03446, 0.03476, 0.03502, 0.03516, 0.03558, 0.03587, 0.03598, 0.03629, 0.03670, 0.03680, 0.03695, 0.03708, 0.03709, 0.03740, 0.03767, 0.03773, 0.03807, 0.03809, 0.03817, 0.03835, 0.03843, 0.03845, 0.03849, 0.03874, 0.03879, 0.03887, 0.03956, 0.03964, 0.03965, 0.04002, 0.04019, 0.04037, 0.04054, 0.04077, 0.04101, 0.04104, 0.04117, 0.04120, 0.04136, 0.04162, 0.04172, 0.04219, 0.04219, 0.04233, 0.04249, 0.04249, 0.04250, 0.04271, 0.04285, 0.04315, 0.04318, 0.04319, 0.04324, 0.04337, 0.04342, 0.04344, 0.04348, 0.04359, 0.04362, 0.04366, 0.04381, 0.04415, 0.04422, 0.04446, 0.04559, 0.04591, 0.04617, 0.04646, 0.04652, 0.04713, 0.04776, 0.04788, 0.04799, 0.04847, 0.04853, 0.04907, 0.05049, 0.05128, 0.05136, 0.05141, 0.05148, 0.05153, 0.05158, 0.05203, 0.05219, 0.05236, 0.05261, 0.05275, 0.05301, 0.05305, 0.05341, 0.05384, 0.05435, 0.05440, 0.05481, 0.05502, 0.05511, 0.05529, 0.05538, 0.05578, 0.05635, 0.05647, 0.05656, 0.05669, 0.05700, 0.05719, 0.05755, 0.05781, 0.05806, 0.05846, 0.05878, 0.05886, 0.05915, 0.05919, 0.05934, 0.05963, 0.05980, 0.06000, 0.06037, 0.06044, 0.06092, 0.06116, 0.06155, 0.06167, 0.06171, 0.06175, 0.06184, 0.06229, 0.06243, 0.06256, 0.06275, 0.06319, 0.06340, 0.06345, 0.06364, 0.06380, 0.06390, 0.06391, 0.06395, 0.06406, 0.06408, 0.06451, 0.06453, 0.06509, 0.06514, 0.06582, 0.06586, 0.06608, 0.06609, 0.06612, 0.06624, 0.06634, 0.06641, 0.06669, 0.06680, 0.06697, 0.06701, 0.06745, 0.06749, 0.06754, 0.06775, 0.06778, 0.06790, 0.06793, 0.06796, 0.06806, 0.06816, 0.06834, 0.06841, 0.06864, 0.06888, 0.06910, 0.06914, 0.06929, 0.06929, 0.06930, 0.06943, 0.06945, 0.06977, 0.07034, 0.07068, 0.07069, 0.07081, 0.07108, 0.07113, 0.07123, 0.07131, 0.07133, 0.07134, 0.07191, 0.07217, 0.07228, 0.07243, 0.07347, 0.07365, 0.07368, 0.07373, 0.07383, 0.07385, 0.07445, 0.07446, 0.07478, 0.07503, 0.07556, 0.07562, 0.07575, 0.07581, 0.07629, 0.07636, 0.07667, 0.07685, 0.07703, 0.07789, 0.07790, 0.07837, 0.07848, 0.07947, 0.07982, 0.07993, 0.08068, 0.08082, 0.08110, 0.08115, 0.08159, 0.08264, 0.08278, 0.08329, 0.08355, 0.08366, 0.08367, 0.08417, 0.08419, 0.08419, 0.08475, 0.08485, 0.08504, 0.08522, 0.08532, 0.08540, 0.08550, 0.08555, 0.08573, 0.08597, 0.08608, 0.08641, 0.08685, 0.08705, 0.08732, 0.08741, 0.08769, 0.08771, 0.08820, 0.08834, 0.08855, 0.08896, 0.08899, 0.08917, 0.08924, 0.08924, 0.08926, 0.08945, 0.08982, 0.09027, 0.09043, 0.09080, 0.09104, 0.09161, 0.09201, 0.09201, 0.09264, 0.09280, 0.09299, 0.09374, 0.09420, 0.09426, 0.09459, 0.09465, 0.09493, 0.09509, 0.09512, 0.09551, 0.09552, 0.09620, 0.09626, 0.09643, 0.09759, 0.09772, 0.09772, 0.09839, 0.09848, 0.09848, 0.09859, 0.09861, 0.09871, 0.09937, 0.09948, 0.10015, 0.10035, 0.10038, 0.10070, 0.10081, 0.10098, 0.10101, 0.10110, 0.10144, 0.10195, 0.10241, 0.10272, 0.10316, 0.10349, 0.10393, 0.10396, 0.10419, 0.10427, 0.10494, 0.10497, 0.10499, 0.10520, 0.10520, 0.10530, 0.10575, 0.10576, 0.10581, 0.10591, 0.10647, 0.10649, 0.10737, 0.10791, 0.10794, 0.10824, 0.10855, 0.10876, 0.10883, 0.10924, 0.10993, 0.10997, 0.11029, 0.11029, 0.11061, 0.11106, 0.11126, 0.11185, 0.11191, 0.11199, 0.11212, 0.11270, 0.11305, 0.11315, 0.11315, 0.11354, 0.11432, 0.11477, 0.11480, 0.11587, 0.11594, 0.11597, 0.11618, 0.11667, 0.11670, 0.11710, 0.11747, 0.11775, 0.11786, 0.11798, 0.11821, 0.11851, 0.11901, 0.11909, 0.11915, 0.11995, 0.12029, 0.12048, 0.12056, 0.12056, 0.12171, 0.12198, 0.12220, 0.12245, 0.12254, 0.12355, 0.12480, 0.12494, 0.12543, 0.12546, 0.12573, 0.12577, 0.12629, 0.12641, 0.12693, 0.12724, 0.12726, 0.12814, 0.12822, 0.12840, 0.12850, 0.12893, 0.12953, 0.13016, 0.13103, 0.13116, 0.13125, 0.13134, 0.13146, 0.13243, 0.13266, 0.13373, 0.13391, 0.13393, 0.13444, 0.13453, 0.13463, 0.13612, 0.13667, 0.13729, 0.13770, 0.13814, 0.13830, 0.13886, 0.13887, 0.14018, 0.14041, 0.14085, 0.14130, 0.14135, 0.14149, 0.14338, 0.14343, 0.14343, 0.14382, 0.14392, 0.14414, 0.14436, 0.14480, 0.14622, 0.14648, 0.14741, 0.14751, 0.14843, 0.14914, 0.14916, 0.15002, 0.15031, 0.15071, 0.15089, 0.15261, 0.15269, 0.15276, 0.15346, 0.15419, 0.15441, 0.15449, 0.15460, 0.15469, 0.15547, 0.15585, 0.15604, 0.15630, 0.15726, 0.15733, 0.15782, 0.15829, 0.15863, 0.15902, 0.16016, 0.16052, 0.16078, 0.16080, 0.16105, 0.16123, 0.16213, 0.16344, 0.16359, 0.16416, 0.16420, 0.16444, 0.16451, 0.16477, 0.16484, 0.16558, 0.16578, 0.16670, 0.16691, 0.16706, 0.16744, 0.16762, 0.16829, 0.16847, 0.16855, 0.16861, 0.16916, 0.16941, 0.17016, 0.17056, 0.17115, 0.17125, 0.17192, 0.17240, 0.17240, 0.17291, 0.17309, 0.17336, 0.17392, 0.17441, 0.17459, 0.17575, 0.17584, 0.17596, 0.17611, 0.17772, 0.17856, 0.17880, 0.17900, 0.17918, 0.18094, 0.18204, 0.18205, 0.18252, 0.18316, 0.18333, 0.18372, 0.18373, 0.18376, 0.18603, 0.18621, 0.18629, 0.18687, 0.18742, 0.18922, 0.18931, 0.19010, 0.19055, 0.19137, 0.19137, 0.19152, 0.19244, 0.19284, 0.19348, 0.19403, 0.19454, 0.19471, 0.19490, 0.19503, 0.19681, 0.19722, 0.19834, 0.19936, 0.20010, 0.20218, 0.20262, 0.20304, 0.20341, 0.20376, 0.20494, 0.20504, 0.20524, 0.20528, 0.20552, 0.20615, 0.20621, 0.20670, 0.20753, 0.20828, 0.21067, 0.21167, 0.21188, 0.21321, 0.21412, 0.21487, 0.21691, 0.21713, 0.21728, 0.21790, 0.21886, 0.21890, 0.21946, 0.21970, 0.22132, 0.22228, 0.22340, 0.22543, 0.22549, 0.22582, 0.22633, 0.22640, 0.22658, 0.22682, 0.22688, 0.22695, 0.22727, 0.22943, 0.23070, 0.23096, 0.23261, 0.23409, 0.23462, 0.23523, 0.23592, 0.23609, 0.23819, 0.23969, 0.24000, 0.24036, 0.24059, 0.24337, 0.24433, 0.24445, 0.24503, 0.24626, 0.24634, 0.24687, 0.24783, 0.24974, 0.25048, 0.25057, 0.25070, 0.25339, 0.25411, 0.25454, 0.25607, 0.25814, 0.25841, 0.25868, 0.25904, 0.25951, 0.26214, 0.26357, 0.26394, 0.26436, 0.26478, 0.26763, 0.26850, 0.26996, 0.27076, 0.27411, 0.27419, 0.27478, 0.27551, 0.27553, 0.27553, 0.27752, 0.27876, 0.27977, 0.28000, 0.28081, 0.28220, 0.28277, 0.28291, 0.28313, 0.28359, 0.28492, 0.28576, 0.28774, 0.28780, 0.28837, 0.28945, 0.28984, 0.29330, 0.29752, 0.29760, 0.29926, 0.30028, 0.30215, 0.30398, 0.30678, 0.30809, 0.30847, 0.30918, 0.30951, 0.31014, 0.31042, 0.31134, 0.31136, 0.31214, 0.31524, 0.31588, 0.31632, 0.31666, 0.32025, 0.32260, 0.32451, 0.32487, 0.32531, 0.32670, 0.32697, 0.32800, 0.32843, 0.33150, 0.33363, 0.33445, 0.33569, 0.33674, 0.33830, 0.33872, 0.33933, 0.34315, 0.34444, 0.34686, 0.34787, 0.35183, 0.35225, 0.35287, 0.35857, 0.35875, 0.36265, 0.36269, 0.36482, 0.37436, 0.37446, 0.37729, 0.37846, 0.37895, 0.38758, 0.39093, 0.39110, 0.39129, 0.39369, 0.39817, 0.39861, 0.40254, 0.40260, 0.40305, 0.40424, 0.40445, 0.40554, 0.41336, 0.41625, 0.41912, 0.42133, 0.42574, 0.42887, 0.42893, 0.43552, 0.43912, 0.44271, 0.45022, 0.45049, 0.45158, 0.45470, 0.45552, 0.45860, 0.46377, 0.46500, 0.46722, 0.47138, 0.47613, 0.48200, 0.49551, 0.50962, 0.52365, 0.52400, 0.53008, 0.53431, 0.53801, 0.53885, 0.53996, 0.54616, 0.55390, 0.55697, 0.56252, 0.56381, 0.57993, 0.58727, 0.60287, 0.61361, 0.64448, 0.65605, 0.66612, 0.66887, 0.68660, 0.68949, 0.69482, 0.70933, 0.75816, 0.78771, 0.80919, 0.84408, 0.86884, 0.96250, 0.97324, 1.00000]
primes = [11, 9433, 42533, 102931]
def prod(nss, nd):
return np.prod(nss[:nd])
def shrink(X, c, l):
cm = (int)(l*(1-c))
idremove = []
lenlost = 0.0
i = 0
while(True):
x = list(np.where(X[:,0]==i)[0])
if len(idremove) + len(x) < cm:
idremove += x
lenlost += len(x) * i
i+=1
else:
lenlost += (cm-len(idremove)) * i
idremove += x[:cm-len(idremove)]
break;
X = np.delete(X, idremove, 0)
del idremove[:]
return X
def rdn(date):
y = date[0]
m = date[1]
d = date[2]
if m < 3:
y -= 1
m += 12
return 365 * y + y / 4 - y / 100 + y / 400 + (153 * m - 457) / 5 + d - 306
def parse_date(s):
return list(map(int, s.split('-')))
def date_to_string(s):
return str(s.year) + '-' + str(s.month) + '-' + str(s.day)
def dif_str(str1, str2, type):
if type == "R":
vd = float(str1) - float(str2)
elif type == "D":
date1 = parse_date(str1)
date2 = parse_date(str2)
vd = (date(date1[0], date1[1], date1[2]) - date(date2[0], date2[1], date2[2])).days
else:
vd = 1
return vd
def parse_keys(keys, type):
if type == "R":
return np.array([float(key) for key in keys])
elif type == "D":
keys = [parse_date(key) for key in keys]
return np.array([(date(key[0], key[1], key[2]) - date(1900, 1, 1)).days for key in keys])
else:
return np.array(keys)
def extract_emb(iris_model, model_fnm, neb=128, ncd=0, nd=2):
vf = iris_model.get_layer('lambda_6').output
model_vf = Model(iris_model.layers[0].input, vf)
emb = {}
xs = np.zeros((1, ncd+2, nd + 1))
for id in range(neb * neb):
xs.fill(0)
xs[0, 0, 0] = 1
xs[0,-2:,0] = 1
for d in range(nd):
xs[0, 0, d + 1] = id % neb
id = int(id / neb)
xs[0, -2, :] = xs[0, 0, :]
xs[0, :, 1:] = np.maximum(xs[0, :, 1:], -1) + 1
v = model_vf.predict(xs)[0]
emb[','.join([str(int(s)) for s in xs[0,0,1:]])] = v
pickle.dump(emb, open('tmp/emb-' + os.path.splitext(os.path.basename(model_fnm))[0] + '.pkl', 'wb'))
return emb
|
py | 7dff02452188d4f23bc0b896edf5fa52fb65680b | from typing import Dict, List
from aioquic.h3.events import DataReceived, H3Event, Headers, HeadersReceived
from aioquic.quic.connection import QuicConnection
from aioquic.quic.events import QuicEvent, StreamDataReceived
H0_ALPN = ["hq-32", "hq-31", "hq-30", "hq-29", "hq-28", "hq-27"]
class H0Connection:
"""
An HTTP/0.9 connection object.
"""
def __init__(self, quic: QuicConnection):
self._buffer: Dict[int, bytes] = {}
self._headers_received: Dict[int, bool] = {}
self._is_client = quic.configuration.is_client
self._quic = quic
def handle_event(self, event: QuicEvent) -> List[H3Event]:
http_events: List[H3Event] = []
if isinstance(event, StreamDataReceived) and (event.stream_id % 4) == 0:
data = self._buffer.pop(event.stream_id, b"") + event.data
if not self._headers_received.get(event.stream_id, False):
if self._is_client:
http_events.append(
HeadersReceived(
headers=[], stream_ended=False, stream_id=event.stream_id
)
)
elif data.endswith(b"\r\n") or event.end_stream:
method, path = data.rstrip().split(b" ", 1)
http_events.append(
HeadersReceived(
headers=[(b":method", method), (b":path", path)],
stream_ended=False,
stream_id=event.stream_id,
)
)
data = b""
else:
# incomplete request, stash the data
self._buffer[event.stream_id] = data
return http_events
self._headers_received[event.stream_id] = True
http_events.append(
DataReceived(
data=data, stream_ended=event.end_stream, stream_id=event.stream_id
)
)
return http_events
def send_data(self, stream_id: int, data: bytes, end_stream: bool) -> None:
self._quic.send_stream_data(stream_id, data, end_stream)
def send_headers(
self, stream_id: int, headers: Headers, end_stream: bool = False
) -> None:
if self._is_client:
headers_dict = dict(headers)
data = headers_dict[b":method"] + b" " + headers_dict[b":path"] + b"\r\n"
else:
data = b""
self._quic.send_stream_data(stream_id, data, end_stream)
|
py | 7dff035cd2c040df5d6017aac26089319f525436 | import numpy as np
import torch
from tinygrad.tensor import Tensor
x_init = np.random.randn(1,3).astype(np.float32)
W_init = np.random.randn(3,3).astype(np.float32)
m_init = np.random.randn(1,3).astype(np.float32)
def test_tinygrad():
x = Tensor(x_init)
W = Tensor(W_init)
m = Tensor(m_init)
out = x.dot(W)
outr = out.relu()
outl = outr.logsoftmax()
outm = outl.mul(m)
outa = outm.add(m)
outx = outa.sum()
outx.backward()
return outx.data, x.grad, W.grad
def test_pytorch():
x = torch.tensor(x_init, requires_grad=True)
W = torch.tensor(W_init, requires_grad=True)
m = torch.tensor(m_init)
out = x.matmul(W)
outr = out.relu()
outl = torch.nn.functional.log_softmax(outr, dim=1)
outm = outl.mul(m)
outa = outm.add(m)
outx = outa.sum()
outx.backward()
return outx.detach().numpy(), x.grad, W.grad
for x,y in zip(test_tinygrad(), test_pytorch()):
print(x,y)
np.testing.assert_allclose(x, y, atol=1e-6)
|
py | 7dff0466b26a4df96a612b0e23e3aa391d9c3af4 | import os.path
import tarfile
from unittest import mock
import pytest
import pre_commit.constants as C
from pre_commit import parse_shebang
from pre_commit.languages import ruby
from pre_commit.prefix import Prefix
from pre_commit.util import cmd_output
from pre_commit.util import resource_bytesio
from testing.util import xfailif_windows
ACTUAL_GET_DEFAULT_VERSION = ruby.get_default_version.__wrapped__
@pytest.fixture
def find_exe_mck():
with mock.patch.object(parse_shebang, 'find_executable') as mck:
yield mck
def test_uses_default_version_when_not_available(find_exe_mck):
find_exe_mck.return_value = None
assert ACTUAL_GET_DEFAULT_VERSION() == C.DEFAULT
def test_uses_system_if_both_gem_and_ruby_are_available(find_exe_mck):
find_exe_mck.return_value = '/path/to/exe'
assert ACTUAL_GET_DEFAULT_VERSION() == 'system'
@pytest.fixture
def fake_gem_prefix(tmpdir):
gemspec = '''\
Gem::Specification.new do |s|
s.name = 'pre_commit_placeholder_package'
s.version = '0.0.0'
s.summary = 'placeholder gem for pre-commit hooks'
s.authors = ['Anthony Sottile']
end
'''
tmpdir.join('placeholder_gem.gemspec').write(gemspec)
yield Prefix(tmpdir)
@xfailif_windows # pragma: win32 no cover
def test_install_ruby_system(fake_gem_prefix):
ruby.install_environment(fake_gem_prefix, 'system', ())
# Should be able to activate and use rbenv install
with ruby.in_env(fake_gem_prefix, 'system'):
_, out, _ = cmd_output('gem', 'list')
assert 'pre_commit_placeholder_package' in out
@xfailif_windows # pragma: win32 no cover
def test_install_ruby_default(fake_gem_prefix):
ruby.install_environment(fake_gem_prefix, C.DEFAULT, ())
# Should have created rbenv directory
assert os.path.exists(fake_gem_prefix.path('rbenv-default'))
# Should be able to activate using our script and access rbenv
with ruby.in_env(fake_gem_prefix, 'default'):
cmd_output('rbenv', '--help')
@xfailif_windows # pragma: win32 no cover
def test_install_ruby_with_version(fake_gem_prefix):
ruby.install_environment(fake_gem_prefix, '2.7.2', ())
# Should be able to activate and use rbenv install
with ruby.in_env(fake_gem_prefix, '2.7.2'):
cmd_output('rbenv', 'install', '--help')
@pytest.mark.parametrize(
'filename',
('rbenv.tar.gz', 'ruby-build.tar.gz', 'ruby-download.tar.gz'),
)
def test_archive_root_stat(filename):
with resource_bytesio(filename) as f:
with tarfile.open(fileobj=f) as tarf:
root, _, _ = filename.partition('.')
assert oct(tarf.getmember(root).mode) == '0o755'
|
py | 7dff04abc463e796a9faaf1f7f0c6c230e01e632 | # Copyright 2018 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.
# [START sheets_quickstart]
from __future__ import print_function
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
# If modifying these scopes, delete the file token.json.
SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
# The ID and range of a sample spreadsheet.
SAMPLE_SPREADSHEET_ID = '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms'
SAMPLE_RANGE_NAME = 'Class Data!A2:E'
def main():
"""Shows basic usage of the Sheets API.
Prints values from a sample spreadsheet.
"""
creds = None
# The file token.json stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.json'):
creds = Credentials.from_authorized_user_file('token.json', SCOPES)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open('token.json', 'w') as token:
token.write(creds.to_json())
service = build('sheets', 'v4', credentials=creds)
# Call the Sheets API
sheet = service.spreadsheets()
result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,
range=SAMPLE_RANGE_NAME).execute()
values = result.get('values', [])
if not values:
print('No data found.')
else:
print('Name, Major:')
for row in values:
# Print columns A and E, which correspond to indices 0 and 4.
print('%s, %s' % (row[0], row[4]))
if __name__ == '__main__':
main()
# [END sheets_quickstart]
|
py | 7dff064466cfb2c408fef9a1f69aefbae2d6e04b | def robot_grid_rec(grid, n, m, mem):
if n < 0 :
return 999
if m < 0 :
return 999
if mem[n][m] != 999:
return mem[n][m]
if grid[n][m] == 999:
return 999
if n == 0 and m == 0:
mem[n][m] = 0
return 0
top = robot_grid_rec(grid, n - 1, m, mem)
left = robot_grid_rec(grid, n, m-1, mem)
if top == 999 and left == 999:
raise AssertionError("Cant find a solution")
mem[n][m] = min(top, left) + 1
return mem[n][m]
def robot_grid_bu(grid):
n = len(grid)
m = len(grid[0])
mem = [[999 for _ in range(m + 1)] for _ in range(n + 1)]
mem[0][1] = -1 # BASE CASE THAT IS THE ROBOT STARTING POSITION
mem[1][0] = -1
for i in range(1, n+1):
for j in range(1, m+1):
if grid[i][j] == 999:
continue
top = mem[i-1][j]
left = mem[i][j-1]
if top == 999 and left == 999:
raise AssertionError("Cant find a solution")
mem[i][j] = min(top, left) + 1
def printPath(mem, n, m):
print("(0,0)")
i = 0
j = 0
while i != n -1 or j != m - 1:
# check right
right = mem[i][j + 1] if j + 1 < m else 999
down = mem[i + 1][j] if i + 1 < n else 999
if right < down:
print("({},{})".format(i, j + 1))
j += 1
else:
print("({},{})".format(i + 1, j))
i += 1
def print_mem(mem):
for i in range(len(mem)):
print(mem[i])
if __name__ == "__main__":
grid = [
[0,0,0],
[0,0,0],
[0,0,0]
]
n = len(grid)
m = len(grid[0])
mem = [[999 for _ in range(m)] for _ in range(n)]
robot_grid_rec(grid, n-1, m-1, mem)
print_mem(mem)
printPath(mem, n, m)
grid = [
[0,-1,0],
[0,-1,0],
[0,0,0]
]
grid = [
[0,-1,0],
[0,-1,0],
[0,-1,0]
] |
py | 7dff066bcab58b79c987df537ac60414c7941953 | # 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.
"""Automated bug filing."""
from __future__ import absolute_import
import datetime
import itertools
import json
from . import grouper
from base import dates
from base import errors
from base import utils
from datastore import data_handler
from datastore import data_types
from datastore import ndb_utils
from handlers import base_handler
from libs import handler
from libs.issue_management import issue_filer
from libs.issue_management import issue_tracker_policy
from libs.issue_management import issue_tracker_utils
from metrics import crash_stats
from metrics import logs
UNREPRODUCIBLE_CRASH_IGNORE_CRASH_TYPES = [
'Out-of-memory', 'Stack-overflow', 'Timeout'
]
TRIAGE_MESSAGE_KEY = 'triage_message'
def _add_triage_message(testcase, message):
"""Add a triage message."""
if testcase.get_metadata(TRIAGE_MESSAGE_KEY) == message:
# Message already exists, skip update.
return
# Re-fetch testcase to get latest entity and avoid race condition in updates.
testcase = data_handler.get_testcase_by_id(testcase.key.id())
testcase.set_metadata(TRIAGE_MESSAGE_KEY, message)
def _create_filed_bug_metadata(testcase):
"""Create a dummy bug entry for a test case."""
metadata = data_types.FiledBug()
metadata.timestamp = datetime.datetime.utcnow()
metadata.testcase_id = testcase.key.id()
metadata.bug_information = int(testcase.bug_information)
metadata.group_id = testcase.group_id
metadata.crash_type = testcase.crash_type
metadata.crash_state = testcase.crash_state
metadata.security_flag = testcase.security_flag
metadata.platform_id = testcase.platform_id
metadata.put()
def _get_excluded_jobs():
"""Return list of jobs excluded from bug filing."""
excluded_jobs = []
jobs = ndb_utils.get_all_from_model(data_types.Job)
for job in jobs:
job_environment = job.get_environment()
# Exclude experimental jobs.
if utils.string_is_true(job_environment.get('EXPERIMENTAL')):
excluded_jobs.append(job.name)
return excluded_jobs
def _is_bug_filed(testcase):
"""Indicate if the bug is already filed."""
# Check if the testcase is already associated with a bug.
if testcase.bug_information:
return True
# Re-check our stored metadata so that we don't file the same testcase twice.
is_bug_filed_for_testcase = data_types.FiledBug.query(
data_types.FiledBug.testcase_id == testcase.key.id()).get()
if is_bug_filed_for_testcase:
return True
return False
def _is_crash_important(testcase):
"""Indicate if the crash is important to file."""
if not testcase.one_time_crasher_flag:
# A reproducible crash is an important crash.
return True
if testcase.status != 'Processed':
# A duplicate or unreproducible crash is not an important crash.
return False
# Testcase is unreproducible. Only those crashes that are crashing frequently
# are important.
if testcase.crash_type in UNREPRODUCIBLE_CRASH_IGNORE_CRASH_TYPES:
return False
# Ensure that there is no reproducible testcase in our group.
if testcase.group_id:
other_reproducible_testcase = data_types.Testcase.query(
data_types.Testcase.group_id == testcase.group_id,
ndb_utils.is_false(data_types.Testcase.one_time_crasher_flag)).get()
if other_reproducible_testcase:
# There is another reproducible testcase in our group. So, this crash is
# not important.
return False
# Get crash statistics data on this unreproducible crash for last X days.
last_hour = crash_stats.get_last_successful_hour()
if not last_hour:
# No crash stats available, skip.
return False
_, rows = crash_stats.get(
end=last_hour,
block='day',
days=data_types.FILE_CONSISTENT_UNREPRODUCIBLE_TESTCASE_DEADLINE,
group_by='reproducible_flag',
where_clause=(
'crash_type = %s AND crash_state = %s AND security_flag = %s' %
(json.dumps(testcase.crash_type), json.dumps(testcase.crash_state),
json.dumps(testcase.security_flag))),
group_having_clause='',
sort_by='total_count',
offset=0,
limit=1)
# Calculate total crash count and crash days count.
crash_days_indices = set([])
total_crash_count = 0
for row in rows:
if 'groups' not in row:
continue
total_crash_count += row['totalCount']
for group in row['groups']:
for index in group['indices']:
crash_days_indices.add(index['hour'])
crash_days_count = len(crash_days_indices)
# Only those unreproducible testcases are important that happened atleast once
# everyday for the last X days and total crash count exceeded our threshold
# limit.
return (crash_days_count ==
data_types.FILE_CONSISTENT_UNREPRODUCIBLE_TESTCASE_DEADLINE and
total_crash_count >=
data_types.FILE_UNREPRODUCIBLE_TESTCASE_MIN_CRASH_THRESHOLD)
def _check_and_update_similar_bug(testcase, issue_tracker):
"""Get list of similar open issues and ones that were recently closed."""
# Get similar testcases from the same group.
similar_testcases_from_group = []
if testcase.group_id:
group_query = data_types.Testcase.query(
data_types.Testcase.group_id == testcase.group_id)
similar_testcases_from_group = ndb_utils.get_all_from_query(
group_query, batch_size=data_types.TESTCASE_ENTITY_QUERY_LIMIT // 2)
# Get testcases with the same crash params. These might not be in the a group
# if they were just fixed.
same_crash_params_query = data_types.Testcase.query(
data_types.Testcase.crash_type == testcase.crash_type,
data_types.Testcase.crash_state == testcase.crash_state,
data_types.Testcase.security_flag == testcase.security_flag,
data_types.Testcase.project_name == testcase.project_name,
data_types.Testcase.status == 'Processed')
similar_testcases_from_query = ndb_utils.get_all_from_query(
same_crash_params_query,
batch_size=data_types.TESTCASE_ENTITY_QUERY_LIMIT // 2)
for similar_testcase in itertools.chain(similar_testcases_from_group,
similar_testcases_from_query):
# Exclude ourself from comparison.
if similar_testcase.key.id() == testcase.key.id():
continue
# Exclude similar testcases without bug information.
if not similar_testcase.bug_information:
continue
# Get the issue object given its ID.
issue = issue_tracker.get_issue(similar_testcase.bug_information)
if not issue:
continue
# If the reproducible issue is not verified yet, bug is still valid and
# might be caused by non-availability of latest builds. In that case,
# don't file a new bug yet.
if similar_testcase.open and not similar_testcase.one_time_crasher_flag:
return True
# If the issue is still open, no need to file a duplicate bug.
if issue.is_open:
return True
# If the issue indicates that this crash needs to be ignored, no need to
# file another one.
policy = issue_tracker_policy.get(issue_tracker.project)
ignore_label = policy.label('ignore')
if ignore_label in issue.labels:
_add_triage_message(
testcase,
('Skipping filing a bug since similar testcase ({testcase_id}) in '
'issue ({issue_id}) is blacklisted with {ignore_label} label.'
).format(
testcase_id=similar_testcase.key.id(),
issue_id=issue.id,
ignore_label=ignore_label))
return True
# If the issue is recently closed, wait certain time period to make sure
# our fixed verification has completed.
if (issue.closed_time and not dates.time_has_expired(
issue.closed_time, hours=data_types.MIN_ELAPSED_TIME_SINCE_FIXED)):
_add_triage_message(
testcase,
('Delaying filing a bug since similar testcase '
'({testcase_id}) in issue ({issue_id}) was just fixed.').format(
testcase_id=similar_testcase.key.id(), issue_id=issue.id))
return True
return False
class Handler(base_handler.Handler):
"""Triage testcases."""
@handler.cron()
def get(self):
"""Handle a get request."""
try:
grouper.group_testcases()
except:
logs.log_error('Error occurred while grouping test cases.')
return
# Free up memory after group task run.
utils.python_gc()
# Get a list of jobs excluded from bug filing.
excluded_jobs = _get_excluded_jobs()
# Get a list of all jobs. This is used to filter testcases whose jobs have
# been removed.
all_jobs = data_handler.get_all_job_type_names()
for testcase_id in data_handler.get_open_testcase_id_iterator():
try:
testcase = data_handler.get_testcase_by_id(testcase_id)
except errors.InvalidTestcaseError:
# Already deleted.
continue
# Skip if testcase's job is removed.
if testcase.job_type not in all_jobs:
continue
# Skip if testcase's job is in exclusions list.
if testcase.job_type in excluded_jobs:
continue
# Skip if we are running progression task at this time.
if testcase.get_metadata('progression_pending'):
continue
# If the testcase has a bug filed already, no triage is needed.
if _is_bug_filed(testcase):
continue
# Check if the crash is important, i.e. it is either a reproducible crash
# or an unreproducible crash happening frequently.
if not _is_crash_important(testcase):
continue
# Require that all tasks like minimizaton, regression testing, etc have
# finished.
if not data_handler.critical_tasks_completed(testcase):
continue
# For testcases that are not part of a group, wait an additional time till
# group task completes.
# FIXME: In future, grouping might be dependent on regression range, so we
# would have to add an additional wait time.
if not testcase.group_id and not dates.time_has_expired(
testcase.timestamp, hours=data_types.MIN_ELAPSED_TIME_SINCE_REPORT):
continue
# If this project does not have an associated issue tracker, we cannot
# file this crash anywhere.
issue_tracker = issue_tracker_utils.get_issue_tracker_for_testcase(
testcase)
if not issue_tracker:
continue
# If there are similar issues to this test case already filed or recently
# closed, skip filing a duplicate bug.
if _check_and_update_similar_bug(testcase, issue_tracker):
continue
# Clean up old triage messages that would be not applicable now.
testcase.delete_metadata(TRIAGE_MESSAGE_KEY, update_testcase=False)
# File the bug first and then create filed bug metadata.
try:
issue_filer.file_issue(testcase, issue_tracker)
except Exception:
logs.log_error('Failed to file issue for testcase %d.' % testcase_id)
continue
_create_filed_bug_metadata(testcase)
logs.log('Filed new issue %s for testcase %d.' %
(testcase.bug_information, testcase_id))
|
py | 7dff07dc8b4246c3aab299854ac307df7a402a7a | #!/usr/bin/env python
import graphitesend
import rospy
import sys
from pal_statistics_msgs.msg import Statistics
from pal_carbon_collector.carbon_collector import CarbonCollector
if __name__ == "__main__":
rospy.init_node('carbon_collector_node')
if not rospy.has_param('~topics'):
print "No topics were specified"
sys.exit(1)
topics = rospy.get_param('~topics')
dry_run = False
if rospy.has_param('~dry_run'):
dry_run = rospy.get_param('~dry_run')
carbon_collector = CarbonCollector(topics, dry_run=dry_run)
rospy.spin()
sys.exit(0)
|
py | 7dff0a035c976ef9125e15944e68742ab3fce8b2 | import sys
import os
import numpy as np
import random
import math
import pandas as pd
import time
input1 = np.array([[0, 6, 4, 5],
[1, 3, 3, 9],
[4, 9, 2, 1],
[9, 6, 1, 2],
[2, 3, 4, 5]])
input2_v1 = np.array([[1, 9, 9, 9, 9, 9],
[1, 1, 0, 1, 0, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 1, 1, 9, 1]])
input2_v2 = np.array([[1, 9, 9, 9, 9, 9],
[1, 1, 1, 1, 1, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 9, 1, 9, 1],
[9, 1, 1, 1, 9, 1]])
input3 = np.array([[1, 6, 4, 5, 1, 4, 3, 6, 8, 7],
[1, 3, 3, 9, 1, 4, 3, 6, 2, 1],
[4, 1, 9, 1, 1, 4, 3, 6, 5, 3],
[9, 6, 1, 2, 1, 4, 3, 6, 2, 1],
[1, 3, 5, 4, 1, 4, 3, 6, 8, 4],
[8, 7, 2, 9, 1, 4, 3, 6, 7, 5],
[8, 7, 2, 9, 1, 4, 3, 6, 7, 5],
[1, 6, 3, 5, 1, 4, 3, 6, 2, 2],
[8, 7, 2, 9, 1, 4, 3, 6, 7, 5],
[1, 6, 3, 5, 1, 4, 3, 6, 2, 2]])
input4 = np.array([[0, 6, 4, 5, 1, 4, 3, 5, 6, 8, 7],
[1, 3, 3, 9, 1, 4, 3, 5, 6, 2, 1],
[4, 1, 9, 1, 1, 4, 3, 5, 6, 5, 3],
[9, 6, 1, 2, 1, 4, 3, 5, 6, 2, 1],
[1, 3, 5, 4, 1, 4, 3, 5, 6, 8, 4],
[8, 7, 2, 9, 1, 4, 3, 5, 6, 7, 5],
[1, 6, 3, 5, 1, 4, 3, 5, 6, 2, 2],
[8, 7, 2, 9, 1, 4, 3, 5, 6, 7, 5],
[1, 6, 3, 5, 1, 4, 3, 5, 6, 2, 2],
[8, 7, 2, 9, 1, 4, 3, 5, 6, 7, 5],
[1, 6, 3, 5, 1, 4, 3, 5, 6, 2, 2]])
# Game class
class Task_one_game():
# Initializes the game by storing the input grid to be used on the different path finding modes.
def __init__(self, input):
self.input = input
# Reference: YouTube. Oct. 4, 2018.
# How the Ant Colony Optimization algorithm works - YouTube.
# [ONLINE] Available at: https://www.youtube.com/watch?v=783ZtAF4j5g.
# [Accessed 19 December 2020].
# Reference: Wikipedia.
# Ant colony optimization algorithms - Wikipedia.
# [ONLINE] Available at: https://en.wikipedia.org/wiki/Ant_colony_optimization_algorithms#Algorithm_and_formulae .
# [Accessed 19 December 2020].
def ant_colony_optimization(self, generations, ants):
grid = self.input
row = grid.shape[0]
col = grid.shape[1]
# Initializes the pheromone grid with ones
pheromone_grid = np.ones((row, col))
gens = generations
# Evaporation rate for the formula
# If a point in the grid doesn't get traversed, its pheromone gradually disipates by the rate
evap_rate = 0.7
ants = ants
alpha = 1.5
def calculate_shortest_path(grid, pheromone_grid, evap_rate, gens, ants):
# Stores the shortest distances for each generation
shortest_dist_found = []
# Iterates through each generation
for gen in range(gens):
# Stores the distances of each ant for the current generation
ants_distances = []
interim_grid = np.zeros((row, col))
pheromone_grid = (1 - evap_rate) * \
pheromone_grid + interim_grid
# print("GENERATION ", generation)
for ant in range(ants):
# For each ant, traverses the grid and gets its path/history and distance made
ant_history, distance_traveled = traverse_grid(
grid, pheromone_grid)
ants_distances.append(distance_traveled)
# If the ant takes 0 distance to reach its destination,
# then it updates the interim_grid by the alpha constant
if distance_traveled == 0:
distance_traveled = 0.7
# Stacks the positions traversed of each ant while dividing the alpha constant
# by the total distance traveled by each ant. This is the formula from Wikipedia
for (x, y) in ant_history:
interim_grid[x][y] += alpha / distance_traveled
# appends the shortest distance after the generation is over
shortest_dist_found.append(np.min(ants_distances))
# Updates the pheromones with the interim_grid by using the formula from Wikipedia.
pheromone_grid = (1 - evap_rate) * \
pheromone_grid + interim_grid
# Removes the starting point added in by the ant to the total,
# adds in the final destination point, as it was not added in the algorithm,
# and prints out the shortest path
print("ACO shortest path: ", np.min(
shortest_dist_found + grid[row - 1][col - 1] - grid[0][0]))
def traverse_grid(grid, pheromone_grid):
# Starts at 0,0
current_node = (0, 0)
end_node = (row - 1, col - 1)
# Initializes the points set traversed by the ant with the starting point
history = set()
history.add(current_node)
distance_traveled = 0
# Generates the initial potential nodes (1,0) and (0,1)
potential_nodes = (
calculate_potential_nodes(history, current_node))
# Parses through the grid while it hasn't reached the end point
# or until there still are potential nodes(nodes act as points on the grid) to go to
while (current_node != end_node) and len(potential_nodes) != 0:
# Updates distance traveled with the current node's value
distance_traveled += grid[current_node[0]][current_node[1]]
# Updates the current node
current_node = choose_node(current_node, potential_nodes)
# Adds it to the history
history.add(current_node)
# Generates new nodes to choose from for the next iteration
potential_nodes = calculate_potential_nodes(
history, current_node)
# Sets the distance_traversed to 100000 if the ant hasn't reached the end
if current_node != end_node:
distance_traveled = 100000
return history, distance_traveled
# The formulas used in this method are from the References above.
def choose_node(current_node, potential_nodes):
potential_nodes_sum = 0
# Calculates sum of each possible node for use in the main probability
for (x, y) in potential_nodes:
if x == current_node[0] + 1:
potential_nodes_sum += calculate_south(current_node)
elif x == current_node[0] - 1:
potential_nodes_sum += calculate_north(current_node)
elif y == current_node[1] + 1:
potential_nodes_sum += calculate_east(current_node)
elif y == current_node[1] - 1:
potential_nodes_sum += calculate_west(current_node)
north_prob = 0
west_prob = 0
east_prob = 0
south_prob = 0
# Calculates the probabilities
for (x, y) in potential_nodes:
if x == current_node[0] + 1:
south_prob = calculate_south(
current_node)/potential_nodes_sum
if x == current_node[0] - 1:
north_prob = calculate_north(
current_node)/potential_nodes_sum
if y == current_node[1] + 1:
east_prob = calculate_east(
current_node)/potential_nodes_sum
if y == current_node[1] - 1:
west_prob = calculate_west(
current_node)/potential_nodes_sum
# roullete_select takes into acocunt chances of probabilities being 0 when passed as parameters
chosen_prob = roullete_select(
[north_prob, west_prob, east_prob, south_prob])
# roullete_select returns the index of the chosen probability
# in the order which they we're inputted above.
# For index 0 it's north_prob, for index 1 it's west_prob and so on... .
# This 'if' function distinguishes which potential node to return based on that index rule.
if chosen_prob == 0:
return (current_node[0] - 1, current_node[1])
elif chosen_prob == 1:
return (current_node[0], current_node[1] - 1)
elif chosen_prob == 2:
return (current_node[0], current_node[1] + 1)
elif chosen_prob == 3:
return (current_node[0] + 1, current_node[1])
def calculate_potential_nodes(history, curr_node):
a = set()
# Calculates if the nodes from the north/east/west/south region with respect to the current_node
# are eligible to be added in the potential_nodes set for the next iteration
# by checking if it hits any walls as well as the ant's history
if curr_node[0] + 1 <= row - 1 and (curr_node[0] + 1, curr_node[1]) not in history:
a.add((curr_node[0] + 1, curr_node[1]))
if curr_node[0] - 1 >= 0 and (curr_node[0] - 1, curr_node[1]) not in history:
a.add((curr_node[0] - 1, curr_node[1]))
if curr_node[1] - 1 >= 0 and (curr_node[0], curr_node[1] - 1) not in history:
a.add((curr_node[0], curr_node[1] - 1))
if curr_node[1] + 1 <= col - 1 and (curr_node[0], curr_node[1] + 1) not in history:
a.add((curr_node[0], curr_node[1] + 1))
return a
def roullete_select(probabilities):
# Randomizes a number to be used in the probability loop below
r = random.uniform(0, 1)
# sum_index acts as the cummulative sum as it increments
# without any need for extra storage use
sum_index = 0
chosen_prob_index = 0
# Iterates through the number of probabilities
for i in range(len(probabilities)):
# Skipping the probabilities in case there are any zero probabilities.
# This happens when the current point has reached one or more walls
# and has no potential node to calculate probability for.
if probabilities[i] == 0:
continue
# If the random number is less than the incremental sum_index,
# then it chooses the current index
# For instance, if we have the probabilities:
# [0.1,0.2,0.1,0.6] and random number 0.3
# then it would choose the 2nd probability as 0.1 + 0.2 is 0.3, which is <= than the rand no.,
# but if you add the next probability it reaches 0.4 which doesn't satisfy the condition,
# making the chosen probability index to stay at 2, which is the 0.2 probability.
if sum_index <= r:
chosen_prob_index = i
sum_index += probabilities[i]
return chosen_prob_index
def calculate_north(a):
# Calculates the probability for the north node, given from the formulas in the references above
if grid[a[0] - 1][a[1]] == 0:
return 0.49
return pheromone_grid[a[0] - 1][a[1]]*(1/grid[a[0] - 1][a[1]])
def calculate_west(a):
# Calculates the probability for the west node, given from the formulas in the references above
if grid[a[0]][a[1] - 1] == 0:
return 0.49
return pheromone_grid[a[0]][a[1] - 1]*(1/grid[a[0]][a[1] - 1])
def calculate_east(a):
# Calculates the probability for the east node, given from the formulas in the references above
if grid[a[0]][a[1] + 1] == 0:
return 0.49
east = pheromone_grid[a[0]][a[1] + 1]*(1/grid[a[0]][a[1] + 1])
return east
def calculate_south(a):
# Calculates the probability for the south node, given from the formulas in the references above
if grid[a[0] + 1][a[1]] == 0:
return 0.49
return pheromone_grid[a[0] + 1][a[1]]*(1/grid[a[0] + 1][a[1]])
calculate_shortest_path(grid, pheromone_grid, evap_rate, gens, ants)
def heuristic(self):
# Sets the boundaries for the while loop below
size_x = self.input.shape[0] - 1
size_y = self.input.shape[1] - 1
grid = self.input
time_spent = 0
# Initializes the positions on the start
x = y = 0
while x <= size_x and y <= size_y:
# Calculates the next point if it's not close to any wall
if x < size_x and y < size_y:
look_right = grid[x, y + 1]
look_down = grid[x + 1, y]
# Chooses the shortest distance point
if look_right == min(look_right, look_down):
time_spent += look_right
y += 1
else:
time_spent += look_down
x += 1
# If it's next to the horizontal walls, it only goes to the right
if size_x == x and y < size_y:
time_spent += grid[x, y + 1]
y += 1
# If it's next to the vertical walls, it only goes below
if size_y == y and x < size_x:
time_spent += grid[x + 1, y]
x += 1
# If it has reached the end, break the loop
if size_y == y and x == size_x:
break
print("Heuristic shortest path: ", time_spent)
# Reference: Wikipedia.
# Dijkstra's algorithm - Wikipedia.
# [ONLINE] Available at: https://en.wikipedia.org/wiki/Dijkstra's_algorithm?fbclid=IwAR3EvRxdGdemWFGdZYVbyARZmViMWMtaoS18Ck4m7QYDVN22tCdl95WmNOk#Algorithm .
# [Accessed 19 December 2020].
def dijkstra(self):
grid = self.input
row = grid.shape[0]
col = grid.shape[1]
# Initializes the node params
start_node = (0, 0)
end_node = (row - 1, col - 1)
current_node = start_node
# Sets the distance grid to a high number (easier to use/visualise compared to infinity - wikipedia)
distance_grid = np.full((row, col), 99999)
# Sets the start distance to 0
distance_grid[0][0] = 0
# Creates a set of unvisitied nodes and adds all the nodes to it - marked as unvisited
unvisited_nodes = set()
for x in range(row):
for y in range(col):
unvisited_nodes.add((x, y))
def start(current_node):
# First neighbour nodes are the right and bottom ones
neighbour_nodes = ((1, 0), (0, 1))
# Parses through the grid until it visits end_node
while end_node in unvisited_nodes:
# Updates the distances of the neighbour nodes
update_distances(current_node, neighbour_nodes)
# Marks the current node as visited
unvisited_nodes.remove(current_node)
current_node = get_next_node()
# Gets the neighbours of the new current_node
neighbour_nodes = update_neighbour_nodes(current_node)
print("Dijkstra shortest path: ",
distance_grid[end_node[0]][end_node[1]])
def update_distances(curr_node, neighbour_nodes):
for (x, y) in neighbour_nodes:
distance = distance_grid[curr_node[0]
][curr_node[1]] + grid[x][y]
if distance_grid[x][y] > distance:
distance_grid[x][y] = distance
def get_next_node():
# Sets an initial min distance to be compared to
min_distance = 9999999
# Initialises min_node with a random pos tuple
min_node = (999, 999)
# Searches through the unvisited nodes the smallest distance and updates min_node
for (x, y) in unvisited_nodes:
if min_distance > distance_grid[x][y]:
min_distance = distance_grid[x][y]
min_node = (x, y)
return min_node
def update_neighbour_nodes(curr_node):
updated_nodes = set()
x = curr_node[0]
y = curr_node[1]
# Checks for walls or possible neighbours that haven't been visited
# based on the indices of the curr_node
if x + 1 < row and (x+1, y) in unvisited_nodes:
updated_nodes.add((x+1, y))
if x - 1 >= 0 and (x-1, y) in unvisited_nodes:
updated_nodes.add((x-1, y))
if y + 1 < col and (x, y + 1) in unvisited_nodes:
updated_nodes.add((x, y + 1))
if y - 1 >= 0 and (x, y - 1) in unvisited_nodes:
updated_nodes.add((x, y - 1))
return updated_nodes
start(current_node)
rand_input = np.random.randint(10, size=(11, 11))
main_input = input4
game = Task_one_game(main_input)
print(main_input)
start = time.time()
game.heuristic()
end = time.time()
print("Time elapsed for Heuristic: ", end - start)
start = time.time()
game.dijkstra()
end = time.time()
print("Time elapsed for Dijkstra: ", end - start)
start = time.time()
game.ant_colony_optimization(generations=50, ants=800)
end = time.time()
print("Time elapsed for ACO: ", end - start)
|
py | 7dff0a9c58b0d0c5cedc20b1efdafe6c1c1d1f05 | import subprocess
import time
from typing import Any, Dict, List
import requests
import determined_common.api.authentication as auth
from determined_common import api
from tests.integrations import config as conf
def det_version() -> str:
output = subprocess.check_output(["det", "--version"], universal_newlines=True) # type: str
return output.split()[1]
def cluster_slots() -> Dict[str, Any]:
"""
cluster_slots returns a dict of slots that each agent has.
:return: Dict[AgentID, List[Slot]]
"""
auth.initialize_session(conf.make_master_url(), try_reauth=True)
r = api.get(conf.make_master_url(), "agents")
assert r.status_code == requests.codes.ok, r.text
json = r.json() # type: Dict[str, Any]
return {agent["id"]: agent["slots"].values() for agent in json.values()}
def num_slots() -> int:
return sum(len(agent_slots) for agent_slots in cluster_slots().values())
def max_slots_per_agent() -> int:
return max(map(len, cluster_slots().values()))
def gpu_slots_per_agent() -> List[int]:
return [
sum(1 if slot["type"] == "gpu" else 0 for slot in slot_list)
for slot_list in cluster_slots().values()
]
def num_free_slots() -> int:
return sum(
0 if slot["container"] else 1
for agent_slots in cluster_slots().values()
for slot in agent_slots
)
def running_on_gpu() -> bool:
return any(
slot["device"]["type"] == "gpu"
for slot_list in cluster_slots().values()
for slot in slot_list
)
def wait_for_agents(min_agent_count: int) -> None:
while True:
if num_agents() >= min_agent_count:
return
print("Waiting for {} agents to register...".format(min_agent_count))
time.sleep(1)
def num_agents() -> int:
auth.initialize_session(conf.make_master_url(), try_reauth=True)
r = api.get(conf.make_master_url(), "agents")
assert r.status_code == requests.codes.ok, r.text
return len(r.json())
|
py | 7dff0b15c661aa83cb5e2f2f99ba5ac7daded503 |
import setuptools
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="spacyjsonnlp",
version='0.1.3',
python_requires='>=3.6',
author="Damir Cavar, Oren Baldinger, Maanvitha Gongalla, Anurag Kumar, Murali Kammili",
author_email="[email protected]",
description="The Python spaCy JSON-NLP package",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/dcavar/spaCy-JSON-NLP",
packages=setuptools.find_packages(),
install_requires=[
'spacy==2.1.0',
'neuralcoref>=4.0',
'pyjsonnlp>=0.2.12',
'benepar[cpu]>=0.1.2',
'cython',
'numpy>=1.14'
],
setup_requires=["cython", "numpy>=1.14", "pytest-runner"],
classifiers=[
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"License :: OSI Approved :: Apache Software License",
"Operating System :: OS Independent",
],
test_suite="tests",
tests_require=["pytest", "coverage"]
)
|
py | 7dff0b3121b2c11ec7d1be5a82823430c3402110 | import os
from dotenv import load_dotenv as ld
|
py | 7dff0be63886cecf13a3f2b47effc1196d91d9c9 | from torch.utils.data import Dataset
import torch
import json, os, random, time
import cv2
import torchvision.transforms as transforms
from data_transform.transform_wrapper import TRANSFORMS
import numpy as np
from utils.utils import get_category_list
import math
from PIL import Image
class BaseSet(Dataset):
def __init__(self, mode="train", cfg=None, transform=None):
self.mode = mode
self.transform = transform
self.cfg = cfg
self.input_size = cfg.INPUT_SIZE
self.color_space = cfg.COLOR_SPACE
self.size = self.input_size
print("Use {} Mode to train network".format(self.color_space))
if self.mode == "train":
print("Loading train data ...", end=" ")
self.json_path = cfg.DATASET.TRAIN_JSON
elif "valid" in self.mode:
print("Loading valid data ...", end=" ")
self.json_path = cfg.DATASET.VALID_JSON
else:
raise NotImplementedError
self.update_transform()
with open(self.json_path, "r") as f:
self.all_info = json.load(f)
self.num_classes = self.all_info["num_classes"]
if not self.cfg.DATASET.USE_CAM_BASED_DATASET or self.mode != 'train':
self.data = self.all_info['annotations']
else:
assert os.path.isfile(self.cfg.DATASET.CAM_DATA_JSON_SAVE_PATH), \
'the CAM-based generated json file does not exist!'
self.data = json.load(open(self.cfg.DATASET.CAM_DATA_JSON_SAVE_PATH))
print("Contain {} images of {} classes".format(len(self.data), self.num_classes))
self.class_weight, self.sum_weight = self.get_weight(self.data, self.num_classes)
if self.cfg.TRAIN.SAMPLER.TYPE == "weighted sampler" and mode == "train":
print('-'*20+' dataset'+'-'*20)
print('class_weight is (the first 10 classes): ')
print(self.class_weight[:10])
num_list, cat_list = get_category_list(self.get_annotations(), self.num_classes, self.cfg)
self.instance_p = np.array([num / sum(num_list) for num in num_list])
self.class_p = np.array([1/self.num_classes for _ in num_list])
num_list = [math.sqrt(num) for num in num_list]
self.square_p = np.array([num / sum(num_list) for num in num_list])
self.class_dict = self._get_class_dict()
def update(self, epoch):
self.epoch = max(0, epoch-self.cfg.TRAIN.TWO_STAGE.START_EPOCH) if self.cfg.TRAIN.TWO_STAGE.DRS else epoch
if self.cfg.TRAIN.SAMPLER.WEIGHTED_SAMPLER.TYPE == "progressive":
self.progress_p = epoch/self.cfg.TRAIN.MAX_EPOCH * self.class_p + (1-epoch/self.cfg.TRAIN.MAX_EPOCH)*self.instance_p
print('self.progress_p', self.progress_p)
def __getitem__(self, index):
print('start get item...')
now_info = self.data[index]
img = self._get_image(now_info)
print('complete get img...')
meta = dict()
image = self.transform(img)
image_label = (
now_info["category_id"] if "test" not in self.mode else 0
) # 0-index
if self.mode not in ["train", "valid"]:
meta["image_id"] = now_info["image_id"]
meta["fpath"] = now_info["fpath"]
return image, image_label, meta
def update_transform(self, input_size=None):
normalize = TRANSFORMS["normalize"](cfg=self.cfg, input_size=input_size)
transform_list = [transforms.ToPILImage()]
transform_ops = (
self.cfg.TRANSFORMS.TRAIN_TRANSFORMS
if self.mode == "train"
else self.cfg.TRANSFORMS.TEST_TRANSFORMS
)
for tran in transform_ops:
transform_list.append(TRANSFORMS[tran](cfg=self.cfg, input_size=input_size))
transform_list.extend([transforms.ToTensor(), normalize])
self.transform = transforms.Compose(transform_list)
def get_num_classes(self):
return self.num_classes
def get_annotations(self):
return self.all_info['annotations']
def __len__(self):
return len(self.all_info['annotations'])
def imread_with_retry(self, fpath):
retry_time = 10
for k in range(retry_time):
try:
img = cv2.imread(fpath)
if img is None:
print("img is None, try to re-read img")
continue
return img
except Exception as e:
if k == retry_time - 1:
assert False, "pillow open {} failed".format(fpath)
time.sleep(0.1)
def _get_image(self, now_info):
fpath = os.path.join(now_info["fpath"])
img = self.imread_with_retry(fpath)
if self.color_space == "RGB":
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
return img
def _get_trans_image(self, img_idx):
now_info = self.data[img_idx]
fpath = os.path.join(now_info["fpath"])
img = self.imread_with_retry(fpath)
if self.color_space == "RGB":
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
return self.transform(img)[None, :, :, :]
def _get_class_dict(self):
class_dict = dict()
for i, anno in enumerate(self.data):
cat_id = (
anno["category_id"] if "category_id" in anno else anno["image_label"]
)
if not cat_id in class_dict:
class_dict[cat_id] = []
class_dict[cat_id].append(i)
return class_dict
def get_weight(self, annotations, num_classes):
num_list = [0] * num_classes
cat_list = []
for anno in annotations:
category_id = anno["category_id"]
num_list[category_id] += 1
cat_list.append(category_id)
max_num = max(num_list)
class_weight = [max_num / i if i != 0 else 0 for i in num_list]
sum_weight = sum(class_weight)
return class_weight, sum_weight
def sample_class_index_by_weight(self):
rand_number, now_sum = random.random() * self.sum_weight, 0
for i in range(self.num_classes):
now_sum += self.class_weight[i]
if rand_number <= now_sum:
return i
|
py | 7dff0be6f06a4fb65d0ffe298eadfc827f8363ee | """
Lists with Duplicates - SOLUTION
"""
# First remove dups from a
# then merge b without adding dups
a = [2, 4, 10, 20, 5, 2, 20, 4]
b = [13, 2, 25, 20, 4, 8]
print(f'BASE LIST: {a}\n')
# USING A LOOP, remove the duplicate items from list a and print out the updated list.
x = []
for i in a:
if i not in x:
x.append(i)
a = x
print(f'Removed Dups: {a}\n')
# SING A LOOP, merge list b into list a without adding any duplicates.
for i in b:
if i not in a:
a.append(i)
print(f'Merged: {a}')
|
py | 7dff0c01d0916fe22b2e87ff1cfa870b024a908d | from math import prod
def persistence(n):
counter = 0
while n > 9:
counter = counter + 1
n = list(map(int,str(n)))
n = prod(n)
return counter
print(persistence(4444))
# Best Practices (I doubt :/)
# import operator
# def persistence(n):
# i = 0
# while n>=10:
# n=reduce(operator.mul,[int(x) for x in str(n)],1)
# i+=1
# return i
|
py | 7dff0d15f599435b128b9c2ddc55c88ea0f5cc40 | import tensorflow as tf
import numpy as np
from typing import Tuple
from modules.utils import PostNet, CBHGLayer, PreNet, PositionalEncoding
from modules.attention import BahdanauAttention, CrossAttentionBLK
class BasePosterior(tf.keras.layers.Layer):
"""Encode the target sequence into latent distributions"""
def __init__(self, name='Posterior', **kwargs):
super(BasePosterior, self).__init__(name=name, **kwargs)
def call(self, inputs, src_enc, src_lengths=None, target_lengths=None
) -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
raise NotImplementedError
@staticmethod
def reparameterize(mu, logvar, nsamples=tf.constant(1), random=tf.constant(True)):
"""
:param mu: [batch, max_time, dim]
:param logvar: [batch, max_time, dim]
:param nsamples: int
:param random: whether sample from N(0, 1) or just use zeros
:return: samples, noises, [batch, nsamples, max_time, dim]
"""
print('tracing back at posterior reparameterize')
batch = tf.shape(mu)[0]
max_time = tf.shape(mu)[1]
dim = tf.shape(mu)[2]
std = tf.math.exp(0.5 * logvar)
if random:
eps = tf.random.normal([batch, nsamples, max_time, dim])
else:
eps = tf.zeros([batch, nsamples, max_time, dim])
samples = eps * tf.expand_dims(std, axis=1) + tf.expand_dims(mu, axis=1)
return samples, eps
@staticmethod
def log_probability(mu, logvar, z=None, eps=None, seq_lengths=None, epsilon=tf.constant(1e-8)):
"""
:param mu: [batch, max_time, dim]
:param logvar: [batch, max_time, dim]
:param z: [batch, nsamples, max_time, dim]
:param eps: [batch, nsamples, max_time, dim]
:param seq_lengths: [batch, ]
:param epsilon: small float number to avoid overflow
:return: log probabilities, [batch, nsamples]
"""
print('tracing back at posterior log-probability')
batch = tf.shape(mu)[0]
max_time = tf.shape(mu)[1]
dim = tf.shape(mu)[2]
std = tf.math.exp(0.5 * logvar)
normalized_samples = (eps if eps is not None
else (z - tf.expand_dims(mu, axis=1))
/ (tf.expand_dims(std, axis=1) + epsilon))
expanded_logvar = tf.expand_dims(logvar, axis=1)
# time_level_log_probs [batch, nsamples, max_time]
time_level_log_probs = -0.5 * (
tf.cast(dim, tf.float32) * tf.math.log(2 * np.pi)
+ tf.reduce_sum(expanded_logvar + normalized_samples ** 2.,
axis=3))
seq_mask = (tf.sequence_mask(seq_lengths, maxlen=max_time, dtype=tf.float32)
if seq_lengths is not None
else tf.ones([batch, max_time]))
seq_mask = tf.expand_dims(seq_mask, axis=1) # [batch, 1, max_time]
sample_level_log_probs = tf.reduce_sum(seq_mask * time_level_log_probs,
axis=2) # [batch, nsamples]
return sample_level_log_probs
def sample(self, inputs, src_enc, input_lengths, src_lengths,
nsamples=tf.constant(1), random=tf.constant(True)) -> Tuple[tf.Tensor, tf.Tensor]:
"""
:param inputs: [batch, tgt_max_time, in_dim]
:param src_enc: [batch, src_max_time, emb_dim]
:param input_lengths: [batch, ]
:param src_lengths: [batch, ]
:param nsamples:
:param random:
:return:
tensor1: samples from the posterior, [batch, nsamples, tgt_max_time, dim]
tensor2: log-probabilities, [batch, nsamples]
"""
raise NotImplementedError
class TransformerPosterior(BasePosterior):
def __init__(self, pre_hidden, pre_drop_rate, pre_activation,
pos_drop_rate, nblk, attention_dim, attention_heads,
temperature, ffn_hidden, latent_dim, name='TransformerPosterior'):
super(TransformerPosterior, self).__init__(name=name)
self.pos_weight = tf.Variable(1.0, trainable=True)
self.prenet = PreNet(units=pre_hidden, drop_rate=pre_drop_rate,
activation=pre_activation, name='decoder_prenet')
self.pe = PositionalEncoding('EncoderPositionEncoding')
self.pe_dropout = tf.keras.layers.Dropout(rate=pos_drop_rate)
self.attentions = []
for i in range(nblk):
attention = CrossAttentionBLK(input_dim=pre_hidden,
attention_dim=attention_dim,
attention_heads=attention_heads,
attention_temperature=temperature,
ffn_hidden=ffn_hidden)
self.attentions.append(attention)
self.mu_projection = tf.keras.layers.Dense(latent_dim,
kernel_initializer='zeros',
name='mu_projection')
self.logvar_projection = tf.keras.layers.Dense(latent_dim,
kernel_initializer='zeros',
name='logvar_projection')
def call(self, inputs, src_enc, src_lengths=None, target_lengths=None, training=None):
print('tracing back at posterior call')
prenet_outs = self.prenet(inputs)
max_time = tf.shape(prenet_outs)[1]
dim = tf.shape(prenet_outs)[2]
pos = self.pe.positional_encoding(max_time, dim)
pos_embs = prenet_outs + self.pos_weight * pos
pos_embs = self.pe_dropout(pos_embs, training=training)
att_outs = pos_embs
for att in self.attentions:
att_outs, alignments = att(
inputs=att_outs, memory=src_enc, query_lengths=target_lengths,
memory_lengths=src_lengths, training=training)
mu = self.mu_projection(att_outs)
logvar = self.logvar_projection(att_outs)
return mu, logvar, None
def sample(self, inputs, src_enc, input_lengths, src_lengths,
nsamples=tf.constant(1), random=tf.constant(True), training=None):
mu, logvar, _ = self.call(inputs, src_enc, input_lengths, src_lengths,
training=training)
samples, eps = self.reparameterize(mu, logvar, nsamples, random)
log_probs = self.log_probability(mu, logvar, eps, input_lengths)
return samples, log_probs
|
py | 7dff0d9a5995fa047058c75206157727b8505701 | #!/usr/bin/env python3
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# See LICENSE.txt included in this distribution for the specific
# language governing permissions and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at LICENSE.txt.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
# Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
# Portions Copyright (c) 2017-2018, Chris Fraire <[email protected]>.
#
import argparse
import logging
import os
import tempfile
from zipfile import ZipFile
from shutil import copyfile
from .utils.log import get_console_logger
"""
deploy war file
"""
def repack_war(logger, sourceWar, targetWar, configFile, defaultConfigFile):
"""
Repack sourceWar into targetWar, performing substitution of configFile
in the process.
"""
WEB_XML = 'WEB-INF/web.xml'
with ZipFile(sourceWar, 'r') as infile, ZipFile(targetWar, 'w') as outfile:
for item in infile.infolist():
data = infile.read(item.filename)
if item.filename == WEB_XML:
logger.debug("Performing substitution of '{}' with '{}'".
format(defaultConfigFile, configFile))
defaultConfigFile = defaultConfigFile.encode()
configFile = configFile.encode()
data = data.replace(defaultConfigFile, configFile)
outfile.writestr(item, data)
def deploy_war(logger, sourceWar, targetWar, configFile=None):
"""
Copy warSource to warTarget (checking existence of both), optionally
repacking the warTarget archive if configuration file resides in
non-default location.
"""
if not os.path.isfile(sourceWar):
logger.error("{} is not a file".format(sourceWar))
if os.path.isdir(targetWar):
orig = targetWar
targetWar = os.path.join(targetWar, os.path.basename(sourceWar))
logger.debug("Target {} is directory, will use {}".
format(orig, targetWar))
# If user does not use default configuration file location then attempt to
# extract WEB-INF/web.xml from the war file using jar or zip utility,
# update the hardcoded values and then update source.war with the new
# WEB-INF/web.xml.
tmpWar = None
DEFAULT_CONFIG_FILE = '/var/opengrok/etc/configuration.xml'
if configFile and configFile != DEFAULT_CONFIG_FILE:
with tempfile.NamedTemporaryFile(prefix='OpenGroktmpWar',
suffix='.war',
delete=False) as tmpWar:
logger.info('Repacking {} with custom configuration path to {}'.
format(sourceWar, tmpWar.name))
repack_war(logger, sourceWar, tmpWar.name, configFile,
DEFAULT_CONFIG_FILE)
sourceWar = tmpWar.name
logger.info("Installing {} to {}".format(sourceWar, targetWar))
copyfile(sourceWar, targetWar)
if tmpWar:
os.remove(tmpWar.name)
def main():
parser = argparse.ArgumentParser(description='Deploy WAR file')
parser.add_argument('-D', '--debug', action='store_true',
help='Enable debug prints')
parser.add_argument('-c', '--config',
help='Path to OpenGrok configuration file')
parser.add_argument('source_war', nargs=1,
help='Path to war file to deploy')
parser.add_argument('target_war', nargs=1,
help='Path where to deploy source war file to')
args = parser.parse_args()
loglevel = logging.INFO
if args.debug:
loglevel = logging.DEBUG
logger = get_console_logger(__name__, loglevel)
deploy_war(logger, args.source_war[0], args.target_war[0], args.config)
print("Start your application server (if it is not already running) "
"or wait until it loads the just installed web application.\n"
"OpenGrok should be available on <HOST>:<PORT>/{APP_CONTEXT}")
if __name__ == '__main__':
main()
|
py | 7dff0da7564a68ce55c372a8984efd52896d431e | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from itertools import combinations
from collections import Counter
import os.path
import numpy as np
from scipy.stats import mode
from scipy.linalg import orth
from numpy.linalg import svd, lstsq, inv, pinv, multi_dot
from scipy.special import logit
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.utils import as_float_array, check_array, check_X_y, check_random_state
#from sklearn.utils.fixes import expit as sigmoid
from scipy.special import expit as sigmoid
#from sklearn.utils.estimator_checks import check_estimator
#from sklearn.exceptions import NotFittedError
from sklearn.preprocessing import LabelBinarizer, label_binarize
from sklearn.linear_model import Ridge, RidgeClassifier, Lasso
from sklearn import metrics
#import matlab.engine
#from cvxpy import *
#from utils import *
#from mysoftclassifier import *
dot = np.dot # alias for np.dot
#def sigmoid(x):
# return 0.5*np.tanh(0.5*x)+0.5
class ELMClassifier(BaseEstimator, ClassifierMixin):
def __init__(self, n_hidden=100, C=1.0, batch_size=None, fit_intercept=False, ovo=False, classes=None, activation_func='sigmoid', return_y=False, random_projection=True, random_state=None):
self.n_hidden = n_hidden
self.C = C
self.W = None
self.b = None
self.beta = None
self.P = None # P = (H'*H+C*I)^-1
self.activation_func = activation_func.lower()
self.batch_size = batch_size
self.fit_intercept = fit_intercept
self.random_projection = random_projection
self.random_state = random_state
self.random_state_ = None
self.ovo = ovo
self.classes = classes#np.array([1,2,3,4,5])
self.return_y = return_y
self.label_binarizer = None
self.fitted_ = False
def _validate_X(self, X):
if len(X.shape)==1:
raise ValueError('X should be a 2-dimensional array.')
# if one feature:
# X = X.reshape(1,-1)
# else: # one sample
# X = X.reshape(-1,1)
if X.shape[0]==0:
raise ValueError('Empty samples.')
if X.shape[1]==0:
raise ValueError('0 feature(s) (shape=(3, 0)) while a minimum of %d is required.'%(1,))
return as_float_array(check_array(X))
def _validate_X_y(self, X, y):
X = self._validate_X(X)
X, y = check_X_y(X, y)
if y.ndim == 2 and y.shape[1] == 1:
y = column_or_1d(y, warn=True)
if np.allclose(np.array(y,dtype=int),y):
self.label_binarizer = LabelBinarizer(neg_label=-2,pos_label=2,sparse_output=False)# y \in {-2,2} according to extreme logistic regression
if self.classes is not None:
self.label_binarizer.fit(self.classes)
y = self.label_binarizer.transform(y)
else:
y = self.label_binarizer.fit_transform(y)
self.classes = self.label_binarizer.classes_
if self.label_binarizer.classes_.shape[0]<2:
raise ValueError('Label contains less than 2 classes.')
else:
self.label_binarizer = None
self.fit_intercept = True
return X, y
def fit(self, X, y, sample_weight=None):
self.fitted_ = False
self.random_state_ = check_random_state(self.random_state)
if np.any(np.isnan(y)):
nonnan_ids = np.logical_not(np.isnan(y))
X = X[nonnan_ids,:]
y = y[nonnan_ids]
X, y = self._validate_X_y(X, y)
N, dx = X.shape
N_ = N-self.n_hidden
self.classes_ = self.classes
#self.n_classes_ = len(self.classes)
if self.random_projection and (self.batch_size is None or self.P is None):
self.b = self.random_state_.uniform(size=self.n_hidden)*2-1
self.W = self.random_state_.uniform(size=(dx,self.n_hidden))*2-1
if self.batch_size is None or N_<=0:
# fit all
if self.random_projection:
if self.activation_func == 'sigmoid':
H = sigmoid(dot(X,self.W)+self.b)
else:
raise NotImplementedError('activation_func="%s" is not implemented.')
else:
self.n_hidden = X.shape[1]
H = X
if self.label_binarizer is None:
if self.ovo:
raise NotImplementedError('OVO for probabilistic label is not implemented yet.')
if sample_weight is not None:
raise NotImplementedError('sampled_weight for probabilistic label is not implemented yet.')
if not hasattr(self,'fit_intercept') or not self.fit_intercept:
raise TypeError('For probabilistic labels, self.fit_intercept must be True.')
output_layer=SoftLogisticRegression(C=self.C, learning_rate=0.01, momentum=0.9, max_iter=200,
random_state=self.random_state, tol=1e-4, verbose=False).fit(H,y)
self.beta = np.r_[output_layer.coefs_[-1].ravel(),output_layer.intercepts_[-1]]
else:
if hasattr(self,'fit_intercept') and self.fit_intercept:
H = np.c_[X,np.ones((N,1))]
nh = self.n_hidden+1
else:
nh = self.n_hidden
if N>self.n_hidden:
if self.ovo:
if sample_weight is not None:
raise NotImplementedError('OVO and sampled_weight at the same time is not implemented yet.')
self.beta = np.empty((nh,self.label_binarizer.classes_.shape[0]*(self.label_binarizer.classes_.shape[0]-1)//2))
cc = 0
for ii in combinations(range(self.label_binarizer.classes_.shape[0]),2):
id_ = np.where(np.logical_or(y[:,ii[0]]==2,y[:,ii[1]]==2))[0]
#if self.C==0:
# self.beta[:,cc] = dot(pinv(H[id_,:]),y[id_,ii[0]])
#else:
Ht_ = H[id_,:].T
self.beta[:,cc] = multi_dot((inv(dot(Ht_,Ht_.T)+self.C*N*1.0/nh*np.eye(nh)),Ht_,y[id_,ii[0]]))
cc += 1
else:
if sample_weight is None:
#if self.C==0:
# self.beta = dot(pinv(H),y)
#else:
self.beta = multi_dot((inv(dot(H.T,H)+self.C*N*1.0/nh*np.eye(nh)),H.T,y))
else:
Ht =sample_weight*H.T
#if self.C==0:
# self.beta = dot(pinv(Ht.T),y)
#else:
self.beta = multi_dot((inv(dot(Ht,H)+self.C*1.0/nh*np.eye(nh)),Ht,y))
else:
if self.ovo:
if sample_weight is not None:
raise NotImplementedError('OVO and sampled_weight at the same time is not implemented yet.')
n_beta = self.label_binarizer.classes_.shape[0]*(self.label_binarizer.classes_.shape[0]-1)//2
self.beta = np.empty((nh,n_beta))
cc = 0
for ii in combinations(range(self.label_binarizer.classes_.shape[0]),2):
id_ = np.where(np.logical_or(y[:,ii[0]]==2,y[:,ii[1]]==2))[0]
H_ = H[id_,:]
#if self.C==0:
# self.beta[:,cc] = dot(pinv(H_),y[id_,ii[0]])
#else:
self.beta[:,cc] = multi_dot((H_.T,inv(dot(H_,H_.T)+self.C*N*1.0/nh*np.eye(N)),y[id_,ii[0]]))
cc += 1
else:
if sample_weight is None:
#if self.C==0:
# self.beta = dot(pinv(H),y)
#else:
self.beta = multi_dot((H.T,inv(dot(H,H.T)+self.C*N*1.0/nh*np.eye(N)),y))
else:
self.beta = multi_dot((H.T,inv((sample_weight*dot(H,H.T)).T+self.C*1.0/nh*np.eye(N)),(sample_weight*y.T).T))
else:
# OS-ELM
raise NotImplementedError('OS-ELM is not implemented yet.')
if self.ovo:
raise NotImplementedError('OVO in batch mode is not implemented yet.')
if sample_weight is not None:
raise NotImplementedError('sampled_weight in batch mode is not implemented yet.')
if N_%self.batch_size==0:
batches = [self.n_hidden]+[self.batch_size]*(N_//self.batch_size)
else:
batches = [self.n_hidden]+[self.batch_size]*(N_//self.batch_size)+[N_%self.batch_size]
#shuffled_id = list(range(N))
#self.random_state_.shuffle(shuffled_id)
#X = X[shuffled_id,:]
#y = y[shuffled_id]
for i in range(len(batches)):
start_n = sum(batches[:i])
end_n = sum(batches[:i+1])
y_part = y[start_n:end_n]
if self.random_projection:
if self.activation_func == 'sigmoid':
H = sigmoid(dot(X[start_n:end_n,:],self.W)+self.b)
if hasattr(self,'fit_intercept') and self.fit_intercept:
H = np.c_[H,np.ones((batches[i],1))]
else:
raise NotImplementedError('activation_func="%s" is not implemented.')
else:
self.n_hidden = X.shape[1]
if hasattr(self,'fit_intercept') and self.fit_intercept:
H = np.c_[X[start_n:end_n,:],np.ones((batches[i],1))]
else:
H = X[start_n:end_n,:]
if i==0 or self.P is None:
if hasattr(self,'fit_intercept') and self.fit_intercept:
nh = self.n_hidden+1
else:
nh = self.n_hidden
self.P = inv(dot(H.T,H)+self.C*N*1.0/nh*np.eye(nh))
self.beta = multi_dot((self.P,H.T,y_part))
else:
if N==1:
h = H.ravel()
hht = np.outer(h,h)
self.P = self.P - multi_dot((self.P,hht,self.P))/(1.+(self.P*hht).sum())
else:
PHt = dot(self.P,H.T)
self.P = self.P - multi_dot((PHt,inv(dot(H,PHt)+np.eye(batches[i])),H,self.P))
self.beta = self.beta + dot(dot(self.P,H.T),y_part-dot(H,self.beta))
self.fitted_ = True
return self
def fit_transform(self, X, y):
return self.fit(X,y).transform(X)
def transform(self, X):
return self.decision_function(X)
def decision_function(self, X):
if not self.fitted_:
raise ValueError('This ELMClassifier instance is not fitted yet.')
X = self._validate_X(X)
if self.random_projection:
H = sigmoid(dot(X,self.W)+self.b)
else:
H = X
if hasattr(self,'fit_intercept') and self.fit_intercept:
H = np.hstack((H,np.ones((X.shape[0],1))))
return dot(H,self.beta)
def predict(self, X):
if self.ovo:
yy = self.decision_function(X)
cc = 0
for ii in combinations(range(self.label_binarizer.classes_.shape[0]),2):
id_ = yy[:,cc]>=0
yy[:,cc][id_] = ii[0]
yy[:,cc][np.logical_not(id_)] = ii[1]
cc += 1
yy = mode(yy,axis=1)[0].ravel()
return self.label_binarizer.inverse_transform(label_binarize(yy, range(self.label_binarizer.classes_.shape[0])))
else:
proba, y = self.predict_proba(X,return_y=True)
if y is None:
return proba
else:
return y
def predict_proba(self, X):
# [1] Ngufor, C., & Wojtusiak, J. (2013).
# Learning from large-scale distributed health data: An approximate logistic regression approach.
# In Proceedings of the 30th International Conference on Machine Learning, Atlanta, Georgia, USA, JMLR: W&CP (pp. 1-8).
# [2] Ngufor, C., Wojtusiak, J., Hooker, A., Oz, T., & Hadley, J. (2014, May).
# Extreme Logistic Regression: A Large Scale Learning Algorithm with Application to Prostate Cancer Mortality Prediction.
# In FLAIRS Conference.
#if self.label_binarizer.classes_.shape[0]!=2:
# print('Warning: This is one-vs-all probability for each class.')
if self.ovo:
proba = label_binarize(self.predict(X),self.label_binarizer.classes_)
"""
K = self.label_binarizer.classes_.shape[0]
proba = np.zeros((X.shape[0],K))
for i in range(K):
cc = 0
for ii in combinations(range(self.label_binarizer.classes_.shape[0]),2):
if ii[0]==i:
proba[:,i] = np.maximum(proba[:,i],proba_[:,cc])
elif ii[1]==i:
proba[:,i] = np.maximum(proba[:,i],1-proba_[:,cc])
cc += 1
"""
else:
hb = self.decision_function(X)
proba = sigmoid(hb)
if proba.ndim>1:
proba = (proba.T/proba.sum(axis=1)).T
if self.return_y:
if self.label_binarizer is None:
return proba, None
else:
return proba, self.label_binarizer.inverse_transform(hb)
else:
return proba
class WeightedELMClassifier(ELMClassifier):
def __init__(self, n_hidden=100, C=1.0, batch_size=None, fit_intercept=False, ovo=False, classes=None, activation_func='sigmoid', random_projection=True, return_y=False, random_state=None):
super(WeightedELMClassifier, self).__init__(n_hidden=n_hidden, C=C, batch_size=batch_size, fit_intercept=fit_intercept, ovo=ovo, classes=classes, activation_func=activation_func, random_projection=random_projection, random_state=random_state, return_y=return_y)
def fit(self, X, y):
yc = Counter(y)
sample_weight = np.empty(X.shape[0])
#average_yc = np.mean(yc.values())
for yy in yc:
#if yc[yy]>average_yc:
# sample_weight[y==yy] = 1./np.sqrt(yc[yy])
#else:
# sample_weight[y==yy] = (np.sqrt(5)-1)/2/np.sqrt(yc[yy])
sample_weight[y==yy] = 1./np.sqrt(yc[yy])
return super(WeightedELMClassifier, self).fit(X, y, sample_weight=sample_weight/sample_weight.sum())
class SSELMClassifier(ELMClassifier):
def __init__(self, n_hidden=100, C=1.0, lambda_=1.0, activation_func='sigmoid', matlab_code_path=None, classes=None, random_projection=True, random_state=None):
super(SSELMClassifier, self).__init__(n_hidden=n_hidden, C=C, batch_size=None, fit_intercept=False, activation_func=activation_func, classes=classes, random_projection=random_projection, random_state=random_state)
self.lambda_ = self.lambda_
self.eng = None
self.L = None
#self.model_matlab = None
if matlab_code_path is None:
self.matlab_code_path = None
else:
self.matlab_code_path = os.path.normpath(matlab_code_path)
def start_matlab_connection(self):
if self.matlab_code_path is not None:
if self.eng is None:
self.eng = matlab.engine.start_matlab()
self.eng.addpath(self.matlab_code_path, nargout=0)
else:
self.eng = None
def close_matlab_connection(self):
if self.eng is not None:
self.eng.exit()
self.eng = None
def compute_graph_laplacian(self, X, params):
self.start_matlab_connection()
self.L = self.eng.laplacian(params, matlab.double(X.tolist()), nargout=1)
def fit(self, X, y):
self.fitted_ = False
self.random_state_ = check_random_state(self.random_state)
X, y = self._validate_X_y(X, y)
if self.matlab_code_path is None:
raise NotImplementedError('No Python implementation for SSELM yet.')
"""
N, dx = X.shape
Nu = np.sum(np.isnan(y))
Nl = N-Nu
self.b = self.random_state_.uniform(size=self.n_hidden)*2-1
self.W = self.random_state_.uniform(size=(dx,self.n_hidden))*2-1
if self.activation_func == 'sigmoid':
H = sigmoid(dot(X,self.W)+self.b)
else:
raise NotImplementedError('activation_func="%s" is not implemented.')
C = np.eye(N,dtype=float)*self.C
C[range(Nl,N),range(Nl,N)] = 0.
L = ???
if Nl>self.n_hidden:
self.beta = multi_dot((inv(np.eye(self.n_hidden,dtype=float)+multi_dot((H.T,C+self.lambda_*L,H))),H.T,C,y))
else:
self.beta = multi_dot(H.T,inv(np.eye(N,dtype=float)+multi_dot((C+self.lambda_*L,H,H.T))),C,y)
"""
else:
unlabeled_id = np.isnan(y)
labeled_id = np.logical_not(unlabeled_id)
self.start_matlab_connection()
params = {'NN':50,'GraphWeights':'binary','GraphDistanceFunction':'euclidean',
'LaplacianNormalize':1,'LaplacianDegree':5,
'NoDisplay':1,'Kernel':'sigmoid','random_state':self.random_state,'random_projection':self.random_projection,
'NumHiddenNeuron':self.n_hidden,'C':self.C,'lambda':self.lambda_}
if self.L is None:
L = self.compute_graph_laplacian(X, params)
else:
L = self.L
import scipy.io as sio
sio.savemat('bb.mat',{'paras':params,'X':X,'Xl':X[labeled_id,:],'Yl':y[labeld_id],'Xu':X[unlabeled_id,:],'L':L})
model_matlab = self.eng.sselm(matlab.double(X[labeled_id,:].tolist()),matlab.double(y[labeled_id].tolist()),
matlab.double(X[unlabeled_id,:].tolist()), L, params, nargout=1)
self.W = self.model_matlab._data['InputWeight']
self.b = self.model_matlab._data['InputBias']
self.beta = self.model_matlab._data['OutputWeight']
self.fitted_ = True
return self
class ELMAutoEncoderClassifier(BaseEstimator, ClassifierMixin):
def __init__(self, n_hiddens, Cs, reg_type='l2',output_layer=None, SSELM_lambda_=1., sigparas=1., sigparas1=1., matlab_code_path=None, random_state=None):
self.n_hiddens = n_hiddens
self.Cs = Cs
self.output_layer = output_layer
self.SSELM_lambda_ = SSELM_lambda_
if type(sigparas)==list:
self.sigparas = sigparas
else:
self.sigparas = [sigparas]*len(self.n_hiddens)
if type(sigparas1)==list:
self.sigparas1 = sigparas1
else:
self.sigparas1 = [sigparas1]*len(self.n_hiddens)
if matlab_code_path is None:
self.matlab_code_path = None
self.layers = None
else:
self.matlab_code_path = os.path.normpath(matlab_code_path)
self.layers_matlab = None
self.eng = None
#self.batch_size = batch_size
#self.fit_intercept = fit_intercept
#self.activation_func = activation_func
self.reg_type = reg_type
self.L = None
self.random_state = random_state
self.random_state_ = None
self.fitted_ = False
def start_matlab_connection(self):
if self.matlab_code_path is not None:
if self.eng is None:
self.eng = matlab.engine.start_matlab()
self.eng.addpath(self.matlab_code_path, nargout=0)
else:
self.eng = None
def close_matlab_connection(self):
if self.eng is not None:
self.eng.exit()
self.eng = None
def _validate_X(self, X):
if len(X.shape)==1:
raise ValueError('X should be a 2-dimensional array.')
# if one feature:
# X = X.reshape(1,-1)
# else: # one sample
# X = X.reshape(-1,1)
if X.shape[0]==0:
raise ValueError('Empty samples.')
if X.shape[1]==0:
raise ValueError('0 feature(s) (shape=(3, 0)) while a minimum of %d is required.'%(1,))
return as_float_array(check_array(X))
def _validate_X_y(self, X, y):
return self.output_layer._validate_X_y(X,y)
def compute_graph_laplacian(self, X, params):
self.start_matlab_connection()
import scipy.io as sio
sio.savemat('aa.mat',{'paras':params,'X':X})
self.L = self.eng.laplacian(params, matlab.double(X.tolist()), nargout=1)
def fit(self, X, y=None):
self.reg_type = self.reg_type.lower()
self.fitted_ = False
self.random_state_ = check_random_state(self.random_state)
if self.output_layer is None or y is None:
X = self._validate_X(X)
else:
X, y = self._validate_X_y(X, y)
if self.matlab_code_path is None:
# our python translation of the original ELM-Autoencoder in Matlab
hidden_layer_num = len(self.n_hiddens)
self.layers = []
X = X.T
dx, N = X.shape
n_layers = np.r_[dx,self.n_hiddens]
for i in range(hidden_layer_num):
W = self.random_state_.rand(n_layers[i+1],n_layers[i])*2.-1.
if n_layers[i+1] > n_layers[i]:
W = orth(W)
else:
W = orth(W.T).T
b = orth(self.random_state_.rand(n_layers[i+1],1)*2-1).ravel()
H = (dot(W,X).T+b).T
#print('AutoEncorder Max Val %f Min Val %f',H.max(),H.min())
H = sigmoid(self.sigparas1[i]*H)
self.layers.append({})
self.layers[-1]['W'] = W
self.layers[-1]['b'] = b
self.layers[-1]['n_hidden'] = n_layers[i+1]
self.layers[-1]['sigpara'] = self.sigparas[i]
self.layers[-1]['sigpara1'] = self.sigparas1[i]
if n_layers[i+1]==n_layers[i]:
C = dot(H,X.T)
_,_,v1 = svd(dot(C.T,C))
u2,_,_ = svd(dot(C,C.T))
self.layers[-1]['beta'] = dot(u2,v1)
else:
if self.Cs[i] == 0:
self.layers[-1]['beta'], _, _, _ = lstsq(H.T,X.T)
elif self.reg_type=='l2':
rho = 0.05
rhohats = np.mean(H,axis=1)
KLsum = np.sum(rho*np.log(rho/rhohats)+(1.-rho)*np.log((1.-rho)/(1.-rhohats)))
Hsquare = dot(H,H.T)
HsquareL = np.diag(np.max(Hsquare,axis=1))
self.layers[-1]['beta'] = multi_dot((inv((np.eye(H.shape[0])*KLsum+HsquareL)*self.Cs[i]+Hsquare),H,X.T))
elif self.reg_type=='l1':
tol = 1e-3
"""
beta_ = Variable(X.shape[0],H.shape[0])
prob = Problem(Minimize(norm(beta_*H-X,'fro')+norm(beta_,1)*self.Cs[i]))
prob.solve(solver=SCS,use_indirect=False,eps=tol)#,verbose=True)
self.layers[-1]['beta'] = beta_.value.getA().T
"""
lasso = Lasso(alpha=self.Cs[i]/H.shape[1], fit_intercept=False, precompute='auto', max_iter=3000,
tol=tol, warm_start=False, random_state=self.random_state*2, selection='random')
lasso.fit(H.T,X.T)
self.layers[-1]['beta'] = lasso.coef_.T
else:
raise NotImplementedError('Regularization type "%s" is not implemented.'%self.reg_type)
H = dot(self.layers[-1]['beta'],X)
if n_layers[i+1]==n_layers[i]:
X = H
else:
#print('Layered Max Val %f Min Val %f',H.max(),H.min())
X = sigmoid(self.sigparas[i]*H)
if self.output_layer is not None and y is not None:
self.output_layer.fit(X.T,y)
"""
self.layers.append({})
if np.any(np.isnan(y)): # semi-supervised ELM
nonnan_ids = np.logical_not(np.isnan(y))
Xl = X[:,nonnan_ids].T
yl = y[nonnan_ids]
Xu = X[:,np.logical_not(nonnan_ids)].T
if self.L is None:
L = self.compute_graph_laplacian(X.T, {'NN':50,'GraphWeights':'binary','GraphDistanceFunction':'euclidean',
'LaplacianNormalize':1,'LaplacianDegree':5})
else:
L = self.L
if Nl>self.n_hidden:
self.beta = multi_dot((inv(np.eye(self.n_hidden,dtype=float)+multi_dot((H.T,C+self.SSELM_lambda_*L,H))),H.T,C,y))
else:
self.beta = multi_dot(H.T,inv(np.eye(N,dtype=float)+multi_dot((C+self.SSELM_lambda_*L,H,H.T))),C,y)
else: # normal ELM
if self.Cs[hidden_layer_num] == 0:
self.layers[-1]['beta'], _, _, _ = lstsq(X.T,y.T)
else:
self.layers[-1]['beta'] = multi_dot((inv(np.eye(X.shape[0])/self.Cs[hidden_layer_num]+dot(X,X.T)),X,y.T))
"""
else: # call the original ELM-Autoencoder in Matlab
self.start_matlab_connection()
matlab_X = matlab.double(X.tolist())
matlab_y = matlab.double(y.tolist())
matlab_n_hiddens = matlab.double(list(self.n_hiddens))
matlab_Cs = matlab.double(list(self.Cs))
matlab_sigparas = matlab.double(list(self.sigparas))
matlab_sigparas1 = matlab.double(list(self.sigparas1))
#import scipy.io as sio
#sio.savemat('aa.mat',{'X':X,'y':y,'n_hiddens':self.n_hiddens,'Cs':self.Cs,'sigparas':self.sigparas,'sigparas1':self.sigparas1})
self.layers_matlab = self.eng.elm_autoencoder_train(self.random_state,matlab_X,matlab_y,
matlab_n_hiddens,matlab_Cs,matlab_sigparas,matlab_sigparas1,self.output_layer is not None,nargout=1)
self.fitted_ = True
return self
def fit_transform(self, X, y=None):
return self.fit(X,y).transform(X)
def transform(self, X):
return self.decision_function(X)
def _transform_X(self, X):
X = X.T
hidden_layer_num = len(self.n_hiddens)
for i in range(hidden_layer_num):
H = dot(self.layers[i]['beta'],X)
if i==0:
n_hidden = X.shape[0]
else:
n_hidden = self.layers[i-1]['n_hidden']
if n_hidden == self.layers[i]['n_hidden']:
X = H
else:
X = sigmoid(dot(self.layers[i]['sigpara'],H))
return X.T
def decision_function(self, X):
if not self.fitted_:
raise ValueError('This ELMAutoEncoderClassifier instance is not fitted yet.')
X = self._validate_X(X)
if self.matlab_code_path is None:
X = self._transform_X(X)
if self.output_layer is None:
yy = X
else:
yy = self.output_layer.decision_function(X)
else:
matlab_X = matlab.double(X.tolist())
yy = self.eng.elm_autoencoder_test(self.layers_matlab, matlab_X, nargout=1)
yy = np.array(list(yy._data)).T
return yy
def predict(self, X):
if not self.fitted_:
raise ValueError('This ELMAutoEncoderClassifier instance is not fitted yet.')
X = self._transform_X(self._validate_X(X))
if self.output_layer is None:
raise TypeError('self.output_layer is None.')
y = self.output_layer.predict(X)
if y.ndim>1:
y = y[:,1]
return y
def predict_proba(self, X, return_y=False):
if not self.fitted_:
raise ValueError('This ELMAutoEncoderClassifier instance is not fitted yet.')
X = self._transform_X(self._validate_X(X))
if self.output_layer is None:
raise TypeError('self.output_layer is None.')
yp = self.output_layer.predict_proba(X)
return yp
#def score(self, X, y):
# nonan_ids = np.logical_not(np.isnan(y))
# if self.problem_type == 'classification':
# return metrics.accuracy_score(y[nonan_ids], self.predict(X[nonan_ids,:]))
# else:
# return -metrics.mean_squared_error(y[nonan_ids], self.predict(X[nonan_ids,:]))
class VigilanceELMAutoEncoder(BaseEstimator, ClassifierMixin):
def __init__(self, channel_num, sig_length, spec_length, sig_n_hidden=50, spec_n_hidden=50, n_hiddens=[], sig_C=0.1, spec_C=0.1, Cs=[0.1], sigparas=1., sigparas1=1.,
lr=0.01, mc=0.9, max_epoch_num=50, matlab_code_path=None, verbose=False, random_state=None,to_transpose=False):#, classes_=None
self.channel_num = channel_num
self.sig_length = sig_length
self.spec_length = spec_length
self.sig_n_hidden = sig_n_hidden
self.spec_n_hidden = spec_n_hidden
self.n_hiddens = n_hiddens
self.sig_C = sig_C
self.spec_C = spec_C
self.Cs = Cs
self.sigparas = sigparas
self.sigparas1 = sigparas1
self.lr = lr
self.mc = mc
self.max_epoch_num = max_epoch_num
self.matlab_code_path = matlab_code_path
self.verbose = verbose
self.random_state = random_state
self.to_transpose = to_transpose
self.fitted_ = False
def fit(self, sigs_specs, vigs):
if self.to_transpose:
sigs_specs = np.transpose(sigs_specs,(1,0,2))
# sigs_specs: channel_num x seg_num x (sig_length+spec_length)
if sigs_specs.shape[0]!=self.channel_num:
raise ValueError('sigs_specs.shape[0](%d) != channel_num(%d)'%(sigs_specs.shape[0],self.channel_num))
if sigs_specs.shape[2]!=self.sig_length+self.spec_length:
raise ValueError('sigs_specs.shape[2](%d) != sig_length(%d) + spec_length(%d)'%(sigs_specs.shape[2],self.sig_length,self.spec_length))
self.fitted_ = False
#self.random_state_ = check_random_state(self.random_state) # done in the component classifiers
self.sig_elmaes = [ELMAutoEncoderClassifier([self.sig_n_hidden], [self.sig_C], sigparas=1, sigparas1=1, reg_type='l2',
matlab_code_path=self.matlab_code_path, random_state=self.random_state+i) for i in range(self.channel_num)]
self.spec_elmaes = [ELMAutoEncoderClassifier([self.spec_n_hidden], [self.spec_C], sigparas=1, sigparas1=1, reg_type='l2',
matlab_code_path=self.matlab_code_path, random_state=self.random_state+self.channel_num+i) for i in range(self.channel_num)]
self.later_elmae = ELMAutoEncoderClassifier(self.n_hiddens, self.Cs[:-1], reg_type='l2',
output_layer=SoftLogisticRegression(C=self.Cs[-1], learning_rate=0.01, momentum=0.9, max_iter=200,
random_state=self.random_state, tol=1e-4, verbose=False),
sigparas=self.sigparas, sigparas1=self.sigparas1, matlab_code_path=self.matlab_code_path,# classes_=classes_,
random_state=self.random_state+2*self.channel_num)
## first fit_transform sig_elmaes and spec_elmaes
seg_num = sigs_specs.shape[1]
#X = np.empty((seg_num, (self.sig_n_hidden+self.spec_n_hidden)*self.channel_num))
X = np.empty((seg_num, self.spec_n_hidden*self.channel_num))
for i in range(self.channel_num):
if self.verbose:
print('channel %d/%d'%(i+1,self.channel_num))
#X[:,self.sig_n_hidden*i:self.sig_n_hidden*(i+1)] =\
# self.sig_elmaes[i].fit_transform(sigs_specs[i,:,:self.sig_length], None)
X[:,self.spec_n_hidden*i:self.spec_n_hidden*(i+1)] =\
self.spec_elmaes[i].fit_transform(sigs_specs[i,:,self.sig_length:])
## then fit later_elmae
self.later_elmae.fit(X, vigs)
self.fitted_ = True
return self
def predict(self, sigs_specs):
return self.predict_proba(sigs_specs)
def predict_proba(self, sigs_specs):
if self.to_transpose:
sigs_specs = np.transpose(sigs_specs,(1,0,2))
# sigs_specs: channel_num x seg_num x (sig_length+spec_length)
if sigs_specs.shape[0]!=self.channel_num:
raise ValueError('sigs_specs.shape[0](%d) != channel_num(%d)'%(sigs_specs.shape[0],self.channel_num))
if sigs_specs.shape[2]!=self.sig_length+self.spec_length:
raise ValueError('sigs_specs.shape[2](%d) != sig_length(%d) + spec_length(%d)'%(sigs_specs.shape[2],self.sig_length,self.spec_length))
## first transform using sig_elmaes and spec_elmaes
seg_num = sigs_specs.shape[1]
#X = np.empty((seg_num, (self.sig_n_hidden+self.spec_n_hidden)*self.channel_num))
X = np.empty((seg_num, self.spec_n_hidden*self.channel_num))
for i in range(self.channel_num):
#X[:,self.sig_n_hidden*i:self.sig_n_hidden*(i+1)] =\
# self.sig_elmaes[i].transform(sigs_specs[i,:,:self.sig_length])
X[:,self.spec_n_hidden*i:self.spec_n_hidden*(i+1)] =\
self.spec_elmaes[i].transform(sigs_specs[i,:,self.sig_length:])
yp = self.later_elmae.predict_proba(X)
if type(self.later_elmae.output_layer)==SoftLogisticRegression:
return yp[:,1]
else:
return yp[:,0]
#def score(self, sigs_specs, vigs):
# nonan_ids = np.logical_not(np.isnan(vigs))
# return -metrics.mean_squared_error(vigs[nonan_ids], self.predict(sigs_specs[:,nonan_ids,:]))
## deprecated!
"""
class OSELMClassifier(ELMClassifier):
def __init__(self, n_hidden=100, C=1.0, batch_size=1, activation_func='sigmoid', classes=None, random_state=None):
super(OSELMClassifier, self).__init__(n_hidden=n_hidden,C=C,activation_func=activation_func,classes=classes,random_state=random_state)
self.P = None # P = (H'*H+C*I)^-1
self.batch_size = batch_size
self.random_state_ = check_random_state(self.random_state)
def fit(self, X, y):
self.fitted_ = False
if self.batch_size <= 0:
raise ValueError('batch_size must be larger than 0.')
N = X.shape[0]
N_ = N-self.n_hidden
if N_>0:
if N_%self.batch_size==0:
batches = [self.n_hidden]+[self.batch_size]*(N_//self.batch_size)
else:
batches = [self.n_hidden]+[self.batch_size]*(N_//self.batch_size)+[N_%self.batch_size]
else:
batches = [N]
#shuffled_id = list(range(N))
#self.random_state_.shuffle(shuffled_id)
#X = X[shuffled_id,:]
#y = y[shuffled_id]
for i in range(len(batches)):
start_n = sum(batches[:i])
end_n = sum(batches[:i+1])
self.fit_part(X[start_n:end_n,:],y[start_n:end_n],continue_fit=i!=0)
self.fitted_ = True
return self
def fit_part(self, X, y, continue_fit=True):
#recursive least square
self.fitted_ = False
X, y = self._validate_X_y(X, y)
N, dx = X.shape
if self.activation_func == 'sigmoid':
if not continue_fit or self.P is None:
self.b = self.random_state_.uniform(size=self.n_hidden)*2-1
self.W = self.random_state_.uniform(size=(dx,self.n_hidden))*2-1
H = sigmoid(dot(X,self.W)+self.b)
else:
raise NotImplementedError('activation_func="%s" is not implemented.')
if not continue_fit or self.P is None:
#if N<self.n_hidden:
# raise ValueError('Number of samples (N=%d) cannot be smaller than hidden neuron number (n_hidden=%d) in the initial fit.'%(N,self.n_hidden))
self.P = inv(dot(H.T,H)+self.C*np.eye(self.n_hidden))
self.beta = multi_dot((self.P,H.T,y))
else:
if N==1:
h = H.ravel()
hht = np.outer(h,h)
self.P = self.P - multi_dot((self.P,hht,self.P))/(1.+(self.P*hht).sum())
else:
PHt = dot(self.P,H.T)
self.P = self.P - multi_dot((PHt,inv(dot(H,PHt)+np.eye(N)),H,self.P))
self.beta = self.beta + dot(dot(self.P,H.T),y-dot(H,self.beta))
return self
def predict(self, X):
return super(OSELMClassifier, self).predict(X,allow_not_fitted=True)
"""
if __name__=='__main__':
import copy
import pdb
import timeit
from sklearn import datasets, preprocessing, cross_validation
#check_estimator(ELMClassifier)
#check_estimator(SequentialELMClassifier)
random_state = 1
np.random.seed(random_state)
X, y = datasets.make_classification(n_samples=2000, n_features=20, n_informative=3, n_redundant=2, n_repeated=0, n_classes=3, n_clusters_per_class=2,random_state=random_state)
train_X, test_X, train_y, test_y = cross_validation.train_test_split(X, y, train_size=0.8,random_state=random_state)
scaler = preprocessing.StandardScaler()
train_X = scaler.fit_transform(train_X)
test_X = scaler.transform(test_X)
hnn = 50
C = 1
elmclf = ELMClassifier(C=C, n_hidden=hnn, fit_intercept=False,random_state=random_state)
oselmclf = ELMClassifier(C=C, n_hidden=hnn, fit_intercept=False,batch_size=300, random_state=random_state)
selmclf = SequentialELMClassifier([elmclf,copy.deepcopy(elmclf)])
st_elm = timeit.default_timer()
elmclf.fit(train_X,train_y)
et_elm = timeit.default_timer()
st_oselm = timeit.default_timer()
oselmclf.fit(train_X,train_y)
et_oselm = timeit.default_timer()
st_selm = timeit.default_timer()
selmclf.fit(train_X,train_y)
et_selm = timeit.default_timer()
print('ELM and OS-ELM are consistent: %s.'%np.allclose(elmclf.beta,oselmclf.beta))
print('ELM time: %gs'%(et_elm-st_elm,))
print('OS-ELM time: %g'%(et_oselm-st_oselm,))
print('S-ELM time: %g'%(et_selm-st_selm,))
print('ELM acc: %g'%elmclf.score(test_X,test_y))
print('OS-ELM acc: %g'%oselmclf.score(test_X,test_y))
print('S-ELM acc: %g'%selmclf.score(test_X,test_y))
|
py | 7dff0dbf1e3ad650e5148f01e7ac6bfd65d1cfe7 | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import json
import logging
import warnings
from typing import Any, Dict, List, Optional, Tuple, Union
import ax.service.utils.best_point as best_point_utils
import numpy as np
import pandas as pd
from ax.core.arm import Arm
from ax.core.base_trial import BaseTrial
from ax.core.batch_trial import BatchTrial
from ax.core.data import Data
from ax.core.experiment import Experiment
from ax.core.generator_run import GeneratorRun
from ax.core.metric import Metric
from ax.core.trial import Trial
from ax.core.types import (
TEvaluationOutcome,
TModelPredictArm,
TParameterization,
TParamValue,
)
from ax.modelbridge.dispatch_utils import choose_generation_strategy
from ax.modelbridge.generation_strategy import GenerationStrategy
from ax.modelbridge.modelbridge_utils import get_pending_observation_features
from ax.plot.base import AxPlotConfig
from ax.plot.contour import plot_contour
from ax.plot.exp_utils import exp_to_df
from ax.plot.feature_importances import plot_feature_importance_by_feature
from ax.plot.helper import _format_dict, _get_in_sample_arms
from ax.plot.trace import optimization_trace_single_method
from ax.service.utils.instantiation import (
data_from_evaluations,
make_experiment,
raw_data_to_evaluation,
)
from ax.service.utils.with_db_settings_base import DBSettings, WithDBSettingsBase
from ax.storage.json_store.decoder import (
generation_strategy_from_json,
object_from_json,
)
from ax.storage.json_store.encoder import object_to_json
from ax.utils.common.docutils import copy_doc
from ax.utils.common.executils import retry_on_exception
from ax.utils.common.logger import _round_floats_for_logging, get_logger
from ax.utils.common.typeutils import (
checked_cast,
checked_cast_dict,
checked_cast_optional,
not_none,
)
from botorch.utils.sampling import manual_seed
logger = get_logger(__name__)
CHOLESKY_ERROR_ANNOTATION = (
"Cholesky errors typically occur when the same or very similar "
"arms are suggested repeatedly. This can mean the model has "
"already converged and you should avoid running further trials. "
"It will also help to convert integer or categorical parameters "
"to float ranges where reasonable.\nOriginal error: "
)
class AxClient(WithDBSettingsBase):
"""
Convenience handler for management of experimentation cycle through a
service-like API. External system manages scheduling of the cycle and makes
calls to this client to get next suggestion in the experiment and log back
data from the evaluation of that suggestion.
Note: `AxClient` expects to only propose 1 arm (suggestion) per trial; support
for use cases that require use of batches is coming soon.
Two custom types used in this class for convenience are `TParamValue` and
`TParameterization`. Those are shortcuts for `Union[str, bool, float, int]`
and `Dict[str, Union[str, bool, float, int]]`, respectively.
Args:
generation_strategy: Optional generation strategy. If not set, one is
intelligently chosen based on properties of search space.
db_settings: Settings for saving and reloading the underlying experiment
to a database. Expected to be of type
ax.storage.sqa_store.structs.DBSettings and require SQLAlchemy.
enforce_sequential_optimization: Whether to enforce that when it is
reasonable to switch models during the optimization (as prescribed
by `num_trials` in generation strategy), Ax will wait for enough trials
to be completed with data to proceed. Defaults to True. If set to
False, Ax will keep generating new trials from the previous model
until enough data is gathered. Use this only if necessary;
otherwise, it is more resource-efficient to
optimize sequentially, by waiting until enough data is available to
use the next model.
random_seed: Optional integer random seed, set to fix the optimization
random seed for reproducibility. Works only for Sobol quasi-random
generator and for BoTorch-powered models. For the latter models, the
trials generated from the same optimization setup with the same seed,
will be mostly similar, but the exact parameter values may still vary
and trials latter in the optimizations will diverge more and more.
This is because a degree of randomness is essential for high performance
of the Bayesian optimization models and is not controlled by the seed.
Note: In multi-threaded environments, the random seed is thread-safe,
but does not actually guarantee reproducibility. Whether the outcomes
will be exactly the same for two same operations that use the random
seed, depends on whether the threads modify the random state in the
same order across the two operations.
verbose_logging: Whether Ax should log significant optimization events,
defaults to `True`.
suppress_storage_errors: Whether to suppress SQL storage-related errors if
encounted. Only use if SQL storage is not important for the given use
case, since this will only log, but not raise, an exception if its
encountered while saving to DB or loading from it.
"""
def __init__(
self,
generation_strategy: Optional[GenerationStrategy] = None,
db_settings: Optional[DBSettings] = None,
enforce_sequential_optimization: bool = True,
random_seed: Optional[int] = None,
verbose_logging: bool = True,
suppress_storage_errors: bool = False,
) -> None:
super().__init__(db_settings=db_settings)
if not verbose_logging:
logger.setLevel(logging.WARNING) # pragma: no cover
else:
logger.info(
"Starting optimization with verbose logging. To disable logging, "
"set the `verbose_logging` argument to `False`. Note that float "
"values in the logs are rounded to 2 decimal points."
)
self._generation_strategy = generation_strategy
self._experiment: Optional[Experiment] = None
self._enforce_sequential_optimization = enforce_sequential_optimization
self._random_seed = random_seed
self._suppress_storage_errors = suppress_storage_errors
if random_seed is not None:
logger.warning(
f"Random seed set to {random_seed}. Note that this setting "
"only affects the Sobol quasi-random generator "
"and BoTorch-powered Bayesian optimization models. For the latter "
"models, setting random seed to the same number for two optimizations "
"will make the generated trials similar, but not exactly the same, "
"and over time the trials will diverge more."
)
# ------------------------ Public API methods. ------------------------
def create_experiment(
self,
parameters: List[Dict[str, Union[TParamValue, List[TParamValue]]]],
name: Optional[str] = None,
objective_name: Optional[str] = None,
minimize: bool = False,
parameter_constraints: Optional[List[str]] = None,
outcome_constraints: Optional[List[str]] = None,
status_quo: Optional[TParameterization] = None,
overwrite_existing_experiment: bool = False,
experiment_type: Optional[str] = None,
choose_generation_strategy_kwargs: Optional[Dict[str, Any]] = None,
) -> None:
"""Create a new experiment and save it if DBSettings available.
Args:
parameters: List of dictionaries representing parameters in the
experiment search space.
Required elements in the dictionaries are:
1. "name" (name of parameter, string),
2. "type" (type of parameter: "range", "fixed", or "choice", string),
and one of the following:
3a. "bounds" for range parameters (list of two values, lower bound
first),
3b. "values" for choice parameters (list of values), or
3c. "value" for fixed parameters (single value).
Optional elements are:
1. "log_scale" (for float-valued range parameters, bool),
2. "value_type" (to specify type that values of this parameter should
take; expects "float", "int", "bool" or "str"),
3. "is_fidelity" (bool) and "target_value" (float) for fidelity
parameters,
4. "is_ordered" (bool) for choice parameters, and
5. "is_task" (bool) for task parameters.
objective: Name of the metric used as objective in this experiment.
This metric must be present in `raw_data` argument to `complete_trial`.
name: Name of the experiment to be created.
minimize: Whether this experiment represents a minimization problem.
parameter_constraints: List of string representation of parameter
constraints, such as "x3 >= x4" or "-x3 + 2*x4 - 3.5*x5 >= 2". For
the latter constraints, any number of arguments is accepted, and
acceptable operators are "<=" and ">=".
outcome_constraints: List of string representation of outcome
constraints of form "metric_name >= bound", like "m1 <= 3."
status_quo: Parameterization of the current state of the system.
If set, this will be added to each trial to be evaluated alongside
test configurations.
overwrite_existing_experiment: If an experiment has already been set
on this `AxClient` instance, whether to reset it to the new one.
If overwriting the experiment, generation strategy will be
re-selected for the new experiment and restarted.
To protect experiments in production, one cannot overwrite existing
experiments if the experiment is already stored in the database,
regardless of the value of `overwrite_existing_experiment`.
choose_generation_strategy_kwargs: Keyword arguments to pass to
`choose_generation_strategy` function which determines what
generation strategy should be used when none was specified on init.
"""
if self.db_settings_set and not name:
raise ValueError( # pragma: no cover
"Must give the experiment a name if `db_settings` is not None."
)
if self.db_settings_set:
experiment_id, _ = self._get_experiment_and_generation_strategy_db_id(
experiment_name=not_none(name)
)
if experiment_id:
raise ValueError(
f"Experiment {name} already exists in the database. "
"To protect experiments that are running in production, "
"overwriting stored experiments is not allowed. To "
"start a new experiment and store it, change the "
"experiment's name."
)
if self._experiment is not None:
if overwrite_existing_experiment:
exp_name = self.experiment._name or "untitled"
new_exp_name = name or "untitled"
logger.info(
f"Overwriting existing experiment ({exp_name}) on this client "
f"with new experiment ({new_exp_name}) and restarting the "
"generation strategy."
)
self._generation_strategy = None
else:
raise ValueError(
"Experiment already created for this client instance. "
"Set the `overwrite_existing_experiment` to `True` to overwrite "
"with new experiment."
)
self._experiment = make_experiment(
name=name,
parameters=parameters,
objective_name=objective_name,
minimize=minimize,
parameter_constraints=parameter_constraints,
outcome_constraints=outcome_constraints,
status_quo=status_quo,
experiment_type=experiment_type,
)
try:
self._save_experiment_to_db_if_possible(
experiment=self.experiment,
suppress_all_errors=self._suppress_storage_errors,
)
except Exception:
# Unset the experiment on this `AxClient` instance if encountered and
# raising an error from saving the experiment, to avoid a case where
# overall `create_experiment` call fails with a storage error, but
# `self._experiment` is still set and user has to specify the
# `ooverwrite_existing_experiment` kwarg to re-attempt exp. creation.
self._experiment = None
raise
self._set_generation_strategy(
choose_generation_strategy_kwargs=choose_generation_strategy_kwargs
)
self._save_generation_strategy_to_db_if_possible(
generation_strategy=self.generation_strategy,
suppress_all_errors=self._suppress_storage_errors,
)
@retry_on_exception(
logger=logger,
exception_types=(RuntimeError,),
suppress_all_errors=False,
wrap_error_message_in=CHOLESKY_ERROR_ANNOTATION,
)
def get_next_trial(
self, ttl_seconds: Optional[int] = None
) -> Tuple[TParameterization, int]:
"""
Generate trial with the next set of parameters to try in the iteration process.
Note: Service API currently supports only 1-arm trials.
Args:
ttl_seconds: If specified, will consider the trial failed after this
many seconds. Used to detect dead trials that were not marked
failed properly.
Returns:
Tuple of trial parameterization, trial index
"""
trial = self.experiment.new_trial(
generator_run=self._gen_new_generator_run(), ttl_seconds=ttl_seconds
)
logger.info(
f"Generated new trial {trial.index} with parameters "
f"{_round_floats_for_logging(item=not_none(trial.arm).parameters)}."
)
trial.mark_running(no_runner_required=True)
self._save_new_trial_to_db_if_possible(
experiment=self.experiment,
trial=trial,
suppress_all_errors=self._suppress_storage_errors,
)
self._update_generation_strategy_in_db_if_possible(
generation_strategy=self.generation_strategy,
new_generator_runs=trial.generator_runs,
suppress_all_errors=self._suppress_storage_errors,
)
return not_none(trial.arm).parameters, trial.index
def abandon_trial(self, trial_index: int, reason: Optional[str] = None) -> None:
"""Abandons a trial and adds optional metadata to it.
Args:
trial_index: Index of trial within the experiment.
"""
trial = self._get_trial(trial_index=trial_index)
trial.mark_abandoned(reason=reason)
def complete_trial(
self,
trial_index: int,
raw_data: TEvaluationOutcome,
metadata: Optional[Dict[str, Union[str, int]]] = None,
sample_size: Optional[int] = None,
) -> None:
"""
Completes the trial with given metric values and adds optional metadata
to it.
Args:
trial_index: Index of trial within the experiment.
raw_data: Evaluation data for the trial. Can be a mapping from
metric name to a tuple of mean and SEM, just a tuple of mean and
SEM if only one metric in optimization, or just the mean if there
is no SEM. Can also be a list of (fidelities, mapping from
metric name to a tuple of mean and SEM).
metadata: Additional metadata to track about this run.
sample_size: Number of samples collected for the underlying arm,
optional.
"""
# Validate that trial can be completed.
if not isinstance(trial_index, int): # pragma: no cover
raise ValueError(f"Trial index must be an int, got: {trial_index}.")
trial = self._get_trial(trial_index=trial_index)
self._validate_can_complete_trial(trial=trial)
# Format the data to save.
sample_sizes = {not_none(trial.arm).name: sample_size} if sample_size else {}
evaluations, data = self._make_evaluations_and_data(
trial=trial, raw_data=raw_data, metadata=metadata, sample_sizes=sample_sizes
)
trial._run_metadata = metadata or {}
for metric_name in data.df["metric_name"].values:
if metric_name not in self.experiment.metrics:
logger.info(
f"Data was logged for metric {metric_name} that was not yet "
"tracked on the experiment. Adding it as tracking metric."
)
self.experiment.add_tracking_metric(Metric(name=metric_name))
self.experiment.attach_data(data=data)
trial.mark_completed()
data_for_logging = _round_floats_for_logging(
item=evaluations[next(iter(evaluations.keys()))]
)
logger.info(
f"Completed trial {trial_index} with data: "
f"{_round_floats_for_logging(item=data_for_logging)}."
)
self._save_updated_trial_to_db_if_possible(
experiment=self.experiment,
trial=trial,
suppress_all_errors=self._suppress_storage_errors,
)
def update_trial_data(
self,
trial_index: int,
raw_data: TEvaluationOutcome,
metadata: Optional[Dict[str, Union[str, int]]] = None,
sample_size: Optional[int] = None,
) -> None:
"""
Attaches additional data for completed trial (for example, if trial was
completed with data for only one of the required metrics and more data
needs to be attached).
Args:
trial_index: Index of trial within the experiment.
raw_data: Evaluation data for the trial. Can be a mapping from
metric name to a tuple of mean and SEM, just a tuple of mean and
SEM if only one metric in optimization, or just the mean if there
is no SEM. Can also be a list of (fidelities, mapping from
metric name to a tuple of mean and SEM).
metadata: Additional metadata to track about this run.
sample_size: Number of samples collected for the underlying arm,
optional.
"""
assert isinstance(
trial_index, int
), f"Trial index must be an int, got: {trial_index}." # pragma: no cover
trial = self._get_trial(trial_index=trial_index)
if not trial.status.is_completed:
raise ValueError(
f"Trial {trial.index} has not yet been completed with data."
"To complete it, use `ax_client.complete_trial`."
)
sample_sizes = {not_none(trial.arm).name: sample_size} if sample_size else {}
evaluations, data = self._make_evaluations_and_data(
trial=trial, raw_data=raw_data, metadata=metadata, sample_sizes=sample_sizes
)
trial._run_metadata.update(metadata or {})
for metric_name in data.df["metric_name"].values:
if metric_name not in self.experiment.metrics:
logger.info(
f"Data was logged for metric {metric_name} that was not yet "
"tracked on the experiment. Adding it as tracking metric."
)
self.experiment.add_tracking_metric(Metric(name=metric_name))
# Registering trial data update is needed for generation strategies that
# leverage the `update` functionality of model and bridge setup and therefore
# need to be aware of new data added to experiment. Usually this happends
# seamlessly, by looking at newly completed trials, but in this case trial
# status does not change, so we manually register the new data.
# Currently this call will only result in a `NotImplementedError` if generation
# strategy uses `update` (`GenerationStep.use_update` is False by default).
self.generation_strategy._register_trial_data_update(trial=trial, data=data)
self.experiment.attach_data(data, combine_with_last_data=True)
data_for_logging = _round_floats_for_logging(
item=evaluations[next(iter(evaluations.keys()))]
)
logger.info(
f"Added data: {_round_floats_for_logging(item=data_for_logging)} "
f"to trial {trial.index}."
)
self._save_experiment_to_db_if_possible(
experiment=self.experiment,
suppress_all_errors=self._suppress_storage_errors,
)
def log_trial_failure(
self, trial_index: int, metadata: Optional[Dict[str, str]] = None
) -> None:
"""Mark that the given trial has failed while running.
Args:
trial_index: Index of trial within the experiment.
metadata: Additional metadata to track about this run.
"""
trial = self.experiment.trials[trial_index]
trial.mark_failed()
logger.info(f"Registered failure of trial {trial_index}.")
if metadata is not None:
trial._run_metadata = metadata
self._save_experiment_to_db_if_possible(
experiment=self.experiment,
suppress_all_errors=self._suppress_storage_errors,
)
def attach_trial(
self, parameters: TParameterization, ttl_seconds: Optional[int] = None
) -> Tuple[TParameterization, int]:
"""Attach a new trial with the given parameterization to the experiment.
Args:
parameters: Parameterization of the new trial.
ttl_seconds: If specified, will consider the trial failed after this
many seconds. Used to detect dead trials that were not marked
failed properly.
Returns:
Tuple of parameterization and trial index from newly created trial.
"""
self._validate_search_space_membership(parameters=parameters)
trial = self.experiment.new_trial(ttl_seconds=ttl_seconds).add_arm(
Arm(parameters=parameters)
)
trial.mark_running(no_runner_required=True)
logger.info(
"Attached custom parameterization "
f"{_round_floats_for_logging(item=parameters)} as trial {trial.index}."
)
self._save_new_trial_to_db_if_possible(
experiment=self.experiment,
trial=trial,
suppress_all_errors=self._suppress_storage_errors,
)
return not_none(trial.arm).parameters, trial.index
def get_trial_parameters(self, trial_index: int) -> TParameterization:
"""Retrieve the parameterization of the trial by the given index."""
return not_none(self._get_trial(trial_index).arm).parameters
@copy_doc(best_point_utils.get_best_parameters)
def get_best_parameters(
self,
) -> Optional[Tuple[TParameterization, Optional[TModelPredictArm]]]:
return best_point_utils.get_best_parameters(self.experiment)
def get_trials_data_frame(self) -> pd.DataFrame:
return exp_to_df(exp=self.experiment)
def get_max_parallelism(self) -> List[Tuple[int, int]]:
"""Retrieves maximum number of trials that can be scheduled in parallel
at different stages of optimization.
Some optimization algorithms profit significantly from sequential
optimization (i.e. suggest a few points, get updated with data for them,
repeat, see https://ax.dev/docs/bayesopt.html).
Parallelism setting indicates how many trials should be running simulteneously
(generated, but not yet completed with data).
The output of this method is mapping of form
{num_trials -> max_parallelism_setting}, where the max_parallelism_setting
is used for num_trials trials. If max_parallelism_setting is -1, as
many of the trials can be ran in parallel, as necessary. If num_trials
in a tuple is -1, then the corresponding max_parallelism_setting
should be used for all subsequent trials.
For example, if the returned list is [(5, -1), (12, 6), (-1, 3)],
the schedule could be: run 5 trials with any parallelism, run 6 trials in
parallel twice, run 3 trials in parallel for as long as needed. Here,
'running' a trial means obtaining a next trial from `AxClient` through
get_next_trials and completing it with data when available.
Returns:
Mapping of form {num_trials -> max_parallelism_setting}.
"""
parallelism_settings = []
for step in self.generation_strategy._steps:
parallelism_settings.append(
(step.num_trials, step.max_parallelism or step.num_trials)
)
return parallelism_settings
def get_optimization_trace(
self, objective_optimum: Optional[float] = None
) -> AxPlotConfig:
"""Retrieves the plot configuration for optimization trace, which shows
the evolution of the objective mean over iterations.
Args:
objective_optimum: Optimal objective, if known, for display in the
visualization.
"""
if not self.experiment.trials:
raise ValueError("Cannot generate plot as there are no trials.")
# pyre-fixme[16]: `Optional` has no attribute `objective`.
objective_name = self.experiment.optimization_config.objective.metric.name
best_objectives = np.array(
[
[
checked_cast(Trial, trial).objective_mean
for trial in self.experiment.trials.values()
if trial.status.is_completed
]
]
)
hover_labels = [
_format_dict(not_none(checked_cast(Trial, trial).arm).parameters)
for trial in self.experiment.trials.values()
if trial.status.is_completed
]
return optimization_trace_single_method(
y=(
np.minimum.accumulate(best_objectives, axis=1)
if self.experiment.optimization_config.objective.minimize
else np.maximum.accumulate(best_objectives, axis=1)
),
optimum=objective_optimum,
title="Model performance vs. # of iterations",
ylabel=objective_name.capitalize(),
hover_labels=hover_labels,
)
def get_contour_plot(
self,
param_x: Optional[str] = None,
param_y: Optional[str] = None,
metric_name: Optional[str] = None,
) -> AxPlotConfig:
"""Retrieves a plot configuration for a contour plot of the response
surface. For response surfaces with more than two parameters,
selected two parameters will appear on the axes, and remaining parameters
will be affixed to the middle of their range. If contour params arguments
are not provided, the first two parameters in the search space will be
used. If contour metrics are not provided, objective will be used.
Args:
param_x: name of parameters to use on x-axis for
the contour response surface plots.
param_y: name of parameters to use on y-axis for
the contour response surface plots.
metric_name: Name of the metric, for which to plot the response
surface.
"""
if not self.experiment.trials:
raise ValueError("Cannot generate plot as there are no trials.")
if len(self.experiment.parameters) < 2:
raise ValueError(
"Cannot create a contour plot as experiment has less than 2 "
"parameters, but a contour-related argument was provided."
)
if (param_x or param_y) and not (param_x and param_y):
raise ValueError(
"If `param_x` is provided, `param_y` is "
"required as well, and vice-versa."
)
objective_name = self.objective_name
if not metric_name:
metric_name = objective_name
if not param_x or not param_y:
parameter_names = list(self.experiment.parameters.keys())
param_x = parameter_names[0]
param_y = parameter_names[1]
if param_x not in self.experiment.parameters:
raise ValueError(
f'Parameter "{param_x}" not found in the optimization search space.'
)
if param_y not in self.experiment.parameters:
raise ValueError(
f'Parameter "{param_y}" not found in the optimization search space.'
)
if metric_name not in self.experiment.metrics:
raise ValueError(
f'Metric "{metric_name}" is not associated with this optimization.'
)
if self.generation_strategy.model is not None:
try:
logger.info(
f"Retrieving contour plot with parameter '{param_x}' on X-axis "
f"and '{param_y}' on Y-axis, for metric '{metric_name}'. "
"Ramaining parameters are affixed to the middle of their range."
)
return plot_contour(
model=not_none(self.generation_strategy.model),
param_x=param_x,
param_y=param_y,
metric_name=metric_name,
)
except NotImplementedError:
# Some models don't implement '_predict', which is needed
# for the contour plots.
logger.info(
f"Model {self.generation_strategy.model} does not implement "
"`predict`, so it cannot be used to generate a response "
"surface plot."
)
raise ValueError(
f'Could not obtain contour plot of "{metric_name}" for parameters '
f'"{param_x}" and "{param_y}", as a model with predictive ability, '
"such as a Gaussian Process, has not yet been trained in the course "
"of this optimization."
)
def get_feature_importances(self, relative: bool = True) -> AxPlotConfig:
"""
Get a bar chart showing feature_importances for a metric.
A drop-down controls the metric for which the importances are displayed.
Args:
relative: Whether the values are displayed as percentiles or
as raw importance metrics.
"""
if not self.experiment.trials:
raise ValueError("Cannot generate plot as there are no trials.")
cur_model = self.generation_strategy.model
if cur_model is not None:
try:
return plot_feature_importance_by_feature(cur_model, relative=relative)
except NotImplementedError:
logger.info(
f"Model {self.generation_strategy.model} does not implement "
"`feature_importances`, so it cannot be used to generate "
"this plot. Only certain models, specifically GPEI, implement "
"feature importances."
)
raise ValueError(
"Could not obtain feature_importances for any metrics "
" as a model that can produce feature importances, such as a "
"Gaussian Process, has not yet been trained in the course "
"of this optimization."
)
def load_experiment_from_database(
self,
experiment_name: str,
choose_generation_strategy_kwargs: Optional[Dict[str, Any]] = None,
) -> None:
"""Load an existing experiment from database using the `DBSettings`
passed to this `AxClient` on instantiation.
Args:
experiment_name: Name of the experiment.
Returns:
Experiment object.
"""
experiment, generation_strategy = self._load_experiment_and_generation_strategy(
experiment_name=experiment_name
)
if experiment is None:
raise ValueError(f"Experiment by name '{experiment_name}' not found.")
self._experiment = experiment
logger.info(f"Loaded {experiment}.")
if generation_strategy is None: # pragma: no cover
self._set_generation_strategy(
choose_generation_strategy_kwargs=choose_generation_strategy_kwargs
)
self._save_generation_strategy_to_db_if_possible(
generation_strategy=self.generation_strategy,
suppress_all_errors=self._suppress_storage_errors,
)
else:
self._generation_strategy = generation_strategy
logger.info(
f"Using generation strategy associated with the loaded experiment:"
f" {generation_strategy}."
)
def get_model_predictions(
self, metric_names: Optional[List[str]] = None
) -> Dict[int, Dict[str, Tuple[float, float]]]:
"""Retrieve model-estimated means and covariances for all metrics.
Note: this function retrieves the predictions for the 'in-sample' arms,
which means that the return mapping on this function will only contain
predictions for trials that have been completed with data.
Args:
metric_names: Names of the metrics, for which to retrieve predictions.
All metrics on experiment will be retrieved if this argument was
not specified.
Returns:
A mapping from trial index to a mapping of metric names to tuples
of predicted metric mean and SEM, of form:
{ trial_index -> { metric_name: ( mean, SEM ) } }.
"""
if self.generation_strategy.model is None: # pragma: no cover
raise ValueError("No model has been instantiated yet.")
if metric_names is None and self.experiment.metrics is None:
raise ValueError( # pragma: no cover
"No metrics to retrieve specified on the experiment or as "
"argument to `get_model_predictions`."
)
arm_info, _, _ = _get_in_sample_arms(
model=not_none(self.generation_strategy.model),
metric_names=set(metric_names)
if metric_names is not None
else set(not_none(self.experiment.metrics).keys()),
)
trials = checked_cast_dict(int, Trial, self.experiment.trials)
return {
trial_index: {
m: (
arm_info[not_none(trials[trial_index].arm).name].y_hat[m],
arm_info[not_none(trials[trial_index].arm).name].se_hat[m],
)
for m in arm_info[not_none(trials[trial_index].arm).name].y_hat
}
for trial_index in trials
if not_none(trials[trial_index].arm).name in arm_info
}
def verify_trial_parameterization(
self, trial_index: int, parameterization: TParameterization
) -> bool:
"""Whether the given parameterization matches that of the arm in the trial
specified in the trial index.
"""
return (
not_none(self._get_trial(trial_index=trial_index).arm).parameters
== parameterization
)
# ------------------ JSON serialization & storage methods. -----------------
def save_to_json_file(self, filepath: str = "ax_client_snapshot.json") -> None:
"""Save a JSON-serialized snapshot of this `AxClient`'s settings and state
to a .json file by the given path.
"""
with open(filepath, "w+") as file: # pragma: no cover
file.write(json.dumps(self.to_json_snapshot()))
logger.info(f"Saved JSON-serialized state of optimization to `{filepath}`.")
@staticmethod
def load_from_json_file(
filepath: str = "ax_client_snapshot.json", **kwargs
) -> "AxClient":
"""Restore an `AxClient` and its state from a JSON-serialized snapshot,
residing in a .json file by the given path.
"""
with open(filepath, "r") as file: # pragma: no cover
serialized = json.loads(file.read())
return AxClient.from_json_snapshot(serialized=serialized, **kwargs)
def to_json_snapshot(self) -> Dict[str, Any]:
"""Serialize this `AxClient` to JSON to be able to interrupt and restart
optimization and save it to file by the provided path.
Returns:
A JSON-safe dict representation of this `AxClient`.
"""
return {
"_type": self.__class__.__name__,
"experiment": object_to_json(self._experiment),
"generation_strategy": object_to_json(self._generation_strategy),
"_enforce_sequential_optimization": self._enforce_sequential_optimization,
}
@staticmethod
def from_json_snapshot(serialized: Dict[str, Any], **kwargs) -> "AxClient":
"""Recreate an `AxClient` from a JSON snapshot."""
experiment = object_from_json(serialized.pop("experiment"))
serialized_generation_strategy = serialized.pop("generation_strategy")
ax_client = AxClient(
generation_strategy=generation_strategy_from_json(
generation_strategy_json=serialized_generation_strategy
)
if serialized_generation_strategy is not None
else None,
enforce_sequential_optimization=serialized.pop(
"_enforce_sequential_optimization"
),
**kwargs,
)
ax_client._experiment = experiment
return ax_client
# ---------------------- Private helper methods. ---------------------
@property
def experiment(self) -> Experiment:
"""Returns the experiment set on this Ax client."""
if self._experiment is None:
raise ValueError(
"Experiment not set on Ax client. Must first "
"call load_experiment or create_experiment to use handler functions."
)
return not_none(self._experiment)
@property
def generation_strategy(self) -> GenerationStrategy:
"""Returns the generation strategy, set on this experiment."""
if self._generation_strategy is None:
raise ValueError(
"No generation strategy has been set on this optimization yet."
)
return not_none(self._generation_strategy)
@property
def objective_name(self) -> str:
"""Returns the name of the objective in this optimization."""
opt_config = not_none(self.experiment.optimization_config)
return opt_config.objective.metric.name
def _set_generation_strategy(
self, choose_generation_strategy_kwargs: Optional[Dict[str, Any]] = None
) -> None:
"""Selects the generation strategy and applies specified dispatch kwargs,
if any.
"""
choose_generation_strategy_kwargs = choose_generation_strategy_kwargs or {}
random_seed = choose_generation_strategy_kwargs.pop(
"random_seed", self._random_seed
)
enforce_sequential_optimization = choose_generation_strategy_kwargs.pop(
"enforce_sequential_optimization", self._enforce_sequential_optimization
)
if self._generation_strategy is None:
self._generation_strategy = choose_generation_strategy(
search_space=self.experiment.search_space,
enforce_sequential_optimization=enforce_sequential_optimization,
random_seed=random_seed,
**choose_generation_strategy_kwargs,
)
def _gen_new_generator_run(self, n: int = 1) -> GeneratorRun:
"""Generate new generator run for this experiment.
Args:
n: Number of arms to generate.
"""
# If random seed is not set for this optimization, context manager does
# nothing; otherwise, it sets the random seed for torch, but only for the
# scope of this call. This is important because torch seed is set globally,
# so if we just set the seed without the context manager, it can have
# serious negative impact on the performance of the models that employ
# stochasticity.
with manual_seed(seed=self._random_seed) and warnings.catch_warnings():
# Filter out GPYTorch warnings to avoid confusing users.
warnings.simplefilter("ignore")
return not_none(self.generation_strategy).gen(
experiment=self.experiment,
n=n,
pending_observations=get_pending_observation_features(
experiment=self.experiment
),
)
def _get_trial(self, trial_index: int) -> Trial:
"""Gets trial by given index or raises an error if it does not exist."""
if trial_index in self.experiment.trials:
trial = self.experiment.trials.get(trial_index)
if not isinstance(trial, Trial):
raise NotImplementedError(
"`AxClient` only supports `Trial`, not `BatchTrial`."
)
return trial
raise ValueError(f"Trial {trial_index} does not yet exist.")
def _find_last_trial_with_parameterization(
self, parameterization: TParameterization
) -> int:
"""Given a parameterization, find the last trial in the experiment that
contains an arm with that parameterization.
"""
for trial_idx in sorted(self.experiment.trials.keys(), reverse=True):
if not_none(self._get_trial(trial_idx).arm).parameters == parameterization:
return trial_idx
raise ValueError(
f"No trial on experiment matches parameterization {parameterization}."
)
def _make_evaluations_and_data(
self,
trial: BaseTrial,
raw_data: Union[TEvaluationOutcome, Dict[str, TEvaluationOutcome]],
metadata: Optional[Dict[str, Union[str, int]]],
sample_sizes: Optional[Dict[str, int]] = None,
) -> Tuple[Dict[str, TEvaluationOutcome], Data]:
"""Formats given raw data as Ax evaluations and `Data`.
Args:
trial: Trial within the experiment.
raw_data: Metric outcomes for 1-arm trials, map from arm name to
metric outcomes for batched trials.
sample_size: Integer sample size for 1-arm trials, dict from arm
name to sample size for batched trials. Optional.
metadata: Additional metadata to track about this run.
data_is_for_batched_trials: Whether making evaluations and data for
a batched trial or a 1-arm trial.
"""
if isinstance(trial, BatchTrial):
assert isinstance( # pragma: no cover
raw_data, dict
), "Raw data must be a dict for batched trials."
elif isinstance(trial, Trial):
arm_name = not_none(trial.arm).name
raw_data = {arm_name: raw_data} # pyre-ignore[9]
else: # pragma: no cover
raise ValueError(f"Unexpected trial type: {type(trial)}.")
assert isinstance(raw_data, dict)
not_trial_arm_names = set(raw_data.keys()) - set(trial.arms_by_name.keys())
if not_trial_arm_names:
raise ValueError(
f"Arms {not_trial_arm_names} are not part of trial #{trial.index}."
)
evaluations = {
arm_name: raw_data_to_evaluation(
raw_data=raw_data[arm_name], objective_name=self.objective_name
)
for arm_name in raw_data
}
data = data_from_evaluations(
evaluations=evaluations,
trial_index=trial.index,
sample_sizes=sample_sizes or {},
start_time=(
checked_cast_optional(int, metadata.get("start_time"))
if metadata is not None
else None
),
end_time=(
checked_cast_optional(int, metadata.get("end_time"))
if metadata is not None
else None
),
)
return evaluations, data
# ------------------------------ Validators. -------------------------------
@staticmethod
def _validate_can_complete_trial(trial: BaseTrial) -> None:
if trial.status.is_completed:
raise ValueError(
f"Trial {trial.index} has already been completed with data."
"To add more data to it (for example, for a different metric), "
"use `ax_client.update_trial_data`."
)
if trial.status.is_abandoned or trial.status.is_failed:
raise ValueError(
f"Trial {trial.index} has been marked {trial.status.name}, so it "
"no longer expects data."
)
def _validate_search_space_membership(self, parameters: TParameterization) -> None:
self.experiment.search_space.check_membership(
parameterization=parameters, raise_error=True
)
# `check_membership` uses int and float interchangeably, which we don't
# want here.
for p_name, parameter in self.experiment.search_space.parameters.items():
if not isinstance(parameters[p_name], parameter.python_type):
typ = type(parameters[p_name])
raise ValueError(
f"Value for parameter {p_name} is of type {typ}, expected "
f"{parameter.python_type}. If the intention was to have the "
f"parameter on experiment be of type {typ}, set `value_type` "
f"on experiment creation for {p_name}."
)
# -------- Backward-compatibility with old save / load method names. -------
@staticmethod
def get_recommended_max_parallelism() -> None:
raise NotImplementedError(
"Use `get_max_parallelism` instead; parallelism levels are now "
"enforced in generation strategy, so max parallelism is no longer "
"just recommended."
)
@staticmethod
def load_experiment(experiment_name: str) -> None:
raise NotImplementedError(
"Use `load_experiment_from_database` to load from SQL database or "
"`load_from_json_file` to load optimization state from .json file."
)
@staticmethod
def load(filepath: Optional[str] = None) -> None:
raise NotImplementedError(
"Use `load_experiment_from_database` to load from SQL database or "
"`load_from_json_file` to load optimization state from .json file."
)
@staticmethod
def save(filepath: Optional[str] = None) -> None:
raise NotImplementedError(
"Use `save_to_json_file` to save optimization state to .json file."
)
|
py | 7dff0e1639b0e0c7ec56fecd720c8bdf72eea64e | # Copyright 2019, Kay Hayen, mailto:[email protected]
#
# Python test originally created or extracted from other peoples work. The
# parts from me are licensed as below. It is at least Free Software where
# it's copied from other people. In these cases, that will normally be
# indicated.
#
# 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.
#
def empty():
pass
module_var = None
def calledRepeatedly():
# We measure making that call or not. Lets get the module
# variable look-up out of the game, by making it a local
# variable
called = empty
# construct_begin
called()
# construct_end
import itertools
for x in itertools.repeat(None, 50000):
calledRepeatedly()
print("OK.")
|
py | 7dff0e734a3370823b4183bd6929f05eb3276fd9 | import xlrd
import zipfile
import argparse
import sys
from shutil import rmtree
from PIL import Image
from glob import glob
from os import makedirs, rename
from os.path import join, splitext, basename, exists
from lib.preprocess import resize_and_center_fundus
parser = argparse.ArgumentParser(description='Preprocess Messidor-Original data set.')
parser.add_argument("--data_dir", help="Directory where Messidor-Original resides.",
default="data/messidor")
args = parser.parse_args()
data_dir = str(args.data_dir)
# Create directories for grades.
[makedirs(join(data_dir, str(i))) for i in [0, 1, 2, 3]
if not exists(join(data_dir, str(i)))]
# Create a tmp directory for saving temporary preprocessing files.
tmp_path = join(data_dir, 'tmp')
if exists(tmp_path):
rmtree(tmp_path)
makedirs(tmp_path)
# Find shard zip files.
shards_paths = glob(join(data_dir, "*.zip"))
for shard in shards_paths:
shard_name = splitext(basename(shard))[0]
shard_unpack_dir = join(data_dir, shard_name)
# Unzip shard.
print(f"Unzipping {shard_name}...")
if exists(shard_unpack_dir):
rmtree(shard_unpack_dir)
zip_ref = zipfile.ZipFile(shard, 'r')
zip_ref.extractall(shard_unpack_dir)
zip_ref.close()
# Open annotations file for shard.
annotations_path = join(
data_dir, f"Annotation_{shard_name}.xls")
workbook = xlrd.open_workbook(annotations_path)
worksheet = workbook.sheet_by_index(0)
# Parse annotations file.
for num, row in enumerate(range(1, worksheet.nrows)):
filename = worksheet.cell(row, 0).value
grade = worksheet.cell(row, 2).value
im_path = glob(join(shard_unpack_dir, "**/{}".format(filename)),
recursive=True)[0]
# Find contour of eye fundus in image, and scale
# diameter of fundus to 299 pixels and crop the edges.
res = resize_and_center_fundus(save_path=tmp_path, image_path=im_path,
diameter=299, verbosity=0)
# Status-message.
msg = "\r- Preprocessing image: {0:>6} / {1}".format(
num+1, worksheet.nrows-1)
# Print the status message.
sys.stdout.write(msg)
sys.stdout.flush()
if res != 1:
continue
new_filename = "{0}.jpg".format(splitext(basename(im_path))[0])
# Move the file from the tmp folder to the right grade folder.
rename(join(tmp_path, new_filename),
join(data_dir, str(int(grade)), new_filename))
print()
rmtree(shard_unpack_dir)
# Clean tmp folder.
rmtree(tmp_path)
|
py | 7dff0eae9d1e347077bedfd8aa00a2831fd4645a | # -*- coding: utf-8 -*-
#
# Copyright 2014-2021 BigML
#
# 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.
import os
from .world import world
from nose.tools import eq_
from bigml.api import HTTP_OK
#@step(r'I get the anomaly detector "(.*)"')
def i_get_the_anomaly(step, anomaly):
resource = world.api.get_anomaly(anomaly)
world.status = resource['code']
eq_(world.status, HTTP_OK)
world.anomaly = resource['object']
|
py | 7dff1082e87973e8e109714cbdff9d18a7450d4d | import os
def cheese():
while True:
if os.system("cheese") == 0:
break
|
py | 7dff120c5b9a23216c4cb236a2b06eb86065da69 | # coding: utf-8
import six
from test_server import TestServer
from grab.proxylist import BaseProxySource
from tests.util import build_grab, temp_file
from tests.util import BaseGrabTestCase, TEST_SERVER_PORT
ADDRESS = '127.0.0.1'
class TestProxy(BaseGrabTestCase):
@classmethod
def setUpClass(cls):
super(TestProxy, cls).setUpClass()
cls.extra_servers = {}
for cnt in range(3):
serv = TestServer(address=ADDRESS, port=TEST_SERVER_PORT + 1 + cnt)
serv.start()
cls.extra_servers[serv.port] = {
'server': serv,
'proxy': '%s:%d' % (ADDRESS, serv.port),
}
@classmethod
def tearDownClass(cls):
super(TestProxy, cls).tearDownClass()
for item in cls.extra_servers.values():
item['server'].stop()
def setUp(self):
super(TestProxy, self).setUp()
for item in self.extra_servers.values():
item['server'].reset()
def test_proxy_option(self):
grab = build_grab()
proxy = '%s:%s' % (ADDRESS, self.server.port)
grab.setup(proxy=proxy, proxy_type='http', debug=True)
self.server.response['data'] = '123'
grab.go('http://yandex.ru')
self.assertEqual(b'123', grab.doc.body)
self.assertEqual('yandex.ru', self.server.request['headers']['host'])
def test_deprecated_setup_proxylist(self):
with temp_file() as tmp_file:
proxy = '%s:%s' % (ADDRESS, self.server.port)
grab = build_grab()
with open(tmp_file, 'w') as out:
out.write(proxy)
grab.proxylist.load_file(tmp_file)
self.server.response['get.data'] = '123'
grab.change_proxy()
grab.go('http://yandex.ru')
self.assertEqual(b'123', grab.doc.body)
self.assertEqual('yandex.ru',
self.server.request['headers']['host'])
def test_load_proxylist(self):
with temp_file() as tmp_file:
content = '\n'.join(x['proxy'] for x in
self.extra_servers.values())
with open(tmp_file, 'w') as out:
out.write(content)
# By default auto_change is True
grab = build_grab()
grab.proxylist.load_file(tmp_file)
self.assertEqual(grab.config['proxy_auto_change'], True)
servers = set()
for _ in six.moves.range(10):
grab.go('http://yandex.ru')
servers.add(grab.config['proxy'])
self.assertTrue(len(servers) > 1)
# Disable auto_change
# Change proxy manually
grab = build_grab()
grab.proxylist.load_file(tmp_file)
grab.setup(proxy_auto_change=False)
grab.change_proxy()
self.assertEqual(grab.config['proxy_auto_change'], False)
# TODO: probably call proxy change manually
servers = set()
for _ in six.moves.range(10):
grab.go('http://yandex.ru')
servers.add(grab.config['proxy'])
self.assertEqual(len(servers), 1)
# Disable auto_change
# By default auto_init is True
# Proxylist will not be used by default
grab = build_grab()
grab.proxylist.load_file(tmp_file)
grab.setup(proxy_auto_change=False)
self.assertEqual(grab.config['proxy_auto_change'], False)
grab.go(self.server.get_url())
self.assertEqual(grab.config['proxy'], None)
def test_change_proxy(self):
with temp_file() as tmp_file:
grab = build_grab()
grab.change_proxy()
self.assertEqual(grab.config['proxy'], None)
grab = build_grab()
with open(tmp_file, 'w') as out:
for num in six.moves.range(10):
out.write('server-%d:777\n' % num)
grab.proxylist.load_file(tmp_file)
grab.setup(proxy_auto_change=False)
self.assertEqual(grab.config['proxy'], None)
grab.proxylist.load_file(tmp_file)
self.assertEqual(grab.config['proxy'], None)
grab.proxylist.load_file(tmp_file)
grab.setup(proxy_auto_change=False)
grab.change_proxy()
# pylint: disable=unsupported-membership-test
self.assertTrue('server-' in grab.config['proxy'])
# pylint: enable=unsupported-membership-test
def test_list_proxysource(self):
grab = build_grab()
items = [x['proxy'] for x in self.extra_servers.values()]
grab.proxylist.load_list(items)
grab.go('http://yandex.ru')
servers = [x['server'] for x in self.extra_servers.values()
if x['server'].request['done']]
for serv in servers:
self.assertEqual(serv.request['headers']['host'], 'yandex.ru')
self.assertTrue(grab.doc.headers['listen-port'] in
map(str, self.extra_servers))
def test_custom_proxysource(self):
extra_servers = list(self.extra_servers.values())
class CustomProxySource(BaseProxySource):
def load_raw_data(self):
return '\n'.join(x['proxy'] for x in extra_servers)
grab = build_grab()
grab.setup(proxy_auto_change=False)
grab.proxylist.set_source(CustomProxySource())
grab.change_proxy(random=False)
grab.go('http://yandex.ru')
serv = extra_servers[0]['server']
self.assertEqual((serv.request['headers']['host']), 'yandex.ru')
self.assertEqual(grab.doc.headers['listen-port'], str(serv.port))
grab.change_proxy(random=False)
grab.go('http://yandex.ru')
serv = extra_servers[1]['server']
self.assertEqual(serv.request['headers']['host'], 'yandex.ru')
self.assertEqual(grab.doc.headers['listen-port'], str(serv.port))
def test_baseproxysource_constructor_arguments(self):
src = BaseProxySource()
self.assertEqual(src.config, {'proxy_type': 'http',
'proxy_userpwd': None})
src = BaseProxySource(proxy_type='socks')
self.assertEqual(src.config, {'proxy_type': 'socks',
'proxy_userpwd': None})
src = BaseProxySource(proxy_userpwd='foo:bar')
self.assertEqual(src.config, {'proxy_type': 'http',
'proxy_userpwd': 'foo:bar'})
src = BaseProxySource(foo='bar')
self.assertEqual(src.config, {'proxy_type': 'http',
'proxy_userpwd': None,
'foo': 'bar'})
def test_global_proxy_userpwd_argument(self):
grab = build_grab()
items = ['localhost:1']
grab.proxylist.load_list(items)
self.assertEqual(grab.proxylist.get_next_proxy().username, None)
grab.proxylist.load_list(items, proxy_userpwd='foo:bar')
proxy = grab.proxylist.get_next_proxy()
self.assertEqual(proxy.username, 'foo')
self.assertEqual(proxy.password, 'bar')
items = ['localhost:1' + ':admin:test', 'localhost:2']
grab.proxylist.load_list(items, proxy_userpwd='foo:bar')
proxy = grab.proxylist.get_next_proxy()
self.assertEqual(proxy.username, 'admin')
self.assertEqual(proxy.password, 'test')
def test_global_proxy_type_argument(self):
grab = build_grab()
items = ['localhost:1']
grab.proxylist.load_list(items)
proxy = grab.proxylist.get_next_proxy()
self.assertEqual(proxy.proxy_type, 'http')
grab.proxylist.load_list(items, proxy_type='socks')
proxy = grab.proxylist.get_next_proxy()
self.assertEqual(proxy.proxy_type, 'socks')
def test_setup_with_proxyline(self):
grab = build_grab()
grab.setup_with_proxyline('1.1.1.1:8080')
self.assertEqual(grab.config['proxy'], '1.1.1.1:8080')
self.assertEqual(grab.config['proxy_userpwd'], None)
self.assertEqual(grab.config['proxy_type'], 'http')
def test_setup_with_proxyline_custom_proxy_type(self):
grab = build_grab()
grab.setup_with_proxyline('1.1.1.1:8080', proxy_type='socks')
self.assertEqual(grab.config['proxy'], '1.1.1.1:8080')
self.assertEqual(grab.config['proxy_userpwd'], None)
self.assertEqual(grab.config['proxy_type'], 'socks')
def test_setup_with_proxyline_userpwd(self):
grab = build_grab()
grab.setup_with_proxyline('1.1.1.1:8080:user:pass')
self.assertEqual(grab.config['proxy'], '1.1.1.1:8080')
self.assertEqual(grab.config['proxy_userpwd'], 'user:pass')
self.assertEqual(grab.config['proxy_type'], 'http')
|
py | 7dff125854dd14b27cc0c2966a205718255c7760 | import os
import pdfplumber
from parse_PDF import parse_text_for_events, get_events_list, get_events_dict_list
import time
start_time = time.time()
def get_syllabi_directory_path():
# change current directory to the parent
os.chdir("../")
return os.path.join(os.getcwd(), "sample-syllabi")
def select_syllabi_file(files):
choice = ""
while (not choice.isdigit() or int(choice) < 0 or int(choice) >
len(files)):
os.system('clear')
print("Select a file from sample-syllabi/: ")
for i, file in enumerate(files):
print(f"{i} - {file:<45}")
choice = input("\nSelect a file: ")
os.system("clear")
return files[int(choice)]
def extract_syllabi_text(syllabi):
all_text = ""
with pdfplumber.open(syllabi) as pdf:
# page = pdf.pages[0] - comment out or remove line
# text = page.extract_text() - comment out or remove line
for pdf_page in pdf.pages:
single_page_text = pdf_page.extract_text()
all_text = all_text + '\n' + single_page_text
return all_text
def main():
syllabiPath = get_syllabi_directory_path()
syllabiFiles = os.listdir(syllabiPath)
syllabi = select_syllabi_file(syllabiFiles)
text = extract_syllabi_text(os.path.join(syllabiPath, syllabi))
parse_text_for_events(text)
get_events_list(text)
print(get_events_dict_list(text))
print("The list of the events extracted from the file:", get_events_list(text))
main()
#print("--- %s seconds ---" % (time.time() - start_time))
# keywords = ["OH", "office", "hour", "meeting", "class", "sessions", "drop-in"]
# weekDays = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
# "mon", "tue", "wed", "thu", "thur", "fri", "sat", "sun", "mwt", "tth"]
# weekDaysArr = []
# numsArr = []
# foundKeywords = []
# numIndsArr = []
# keywordIndsArr = []
# weekdayIndsArr = []
# # Splitting characters in String by ',' OR '_', OR '-', OR ... etc
# res = re.split(' |\n', all_text)
# # remove empty spaces from the list of words that were parced
# res = list(filter(None, res))
# """
# for ind, el in enumerate(res):
# if el.isdigit():
# numsArr.append(el)
# numIndsArr.append(ind)
# elif el.lower() in weekDays:
# weekDaysArr.append(el)
# weekdayIndsArr.append(ind)
# elif el.lower() in keywords:
# foundKeywords.append(el)
# keywordIndsArr.append(ind)
# print("{} nums extracted: {}".format(len(numsArr), numsArr))
# print("{} weekdays extracted: {}".format(len(weekDaysArr), weekDaysArr))
# print("{} keywords extracted: {}".format(len(keywordIndsArr), foundKeywords))
# """
# # ATTEMPT 2: extract the keywords and numbers are the located the closest to each other
# # in the list of words
# #print("the closest matching pairs are")
# #pairs = sorted(product(numIndsArr, keywordIndsArr), key=lambda t: abs(t[0]-t[1]))
# # for i in range(len(keywordIndsArr)):
# # currPair = pairs[i]
# # print(currPair, ":", res[currPair[0]], res[currPair[1]])
# # ATTEMPT 3: extracting an words before and after
# # for ind in numIndsArr:
# # print("num", res[ind], res[ind-10:ind+10])
# # issues:
# # PDFs are sometimes formated in 2 columns -- cannot read "across" the line
# # ATTEMPT 5:
# # new logic: 1) extract all numbers 2) search the substrings for keywords
# # create a long string from the result
# strRes = ''.join(map(str, res))
# # par.find_all_regex(main_str=strRes, substr="class") # this will return inds where the word "class" occurs
# keyword_inds = par.find_all_regex(
# main_str=strRes, patterns=keywords) # returns inds of all keywords
# num_inds = par.find_all_nums(strRes)
# for k in keyword_inds: # attempting to match keywords and numbers
# # k==index of the last letter of the keyword
# print("keyword:", strRes[k[0]:k[1]])
# curr_num_inds = par.find_all_nums(strRes[k[1]:k[1]+150])
# curr_times_inds = par.find_am_pm(strRes[k[1]:k[1]+150])
# curr_weekday_inds = par.find_all_regex(
# main_str=strRes[k[1]:k[1]+150], patterns=weekDays)
# # adjust the inds
# curr_num_inds_s = [x[0]+k[1] for x in curr_num_inds]
# curr_num_inds_e = [x[1]+k[1] for x in curr_num_inds]
# curr_times_inds = [x+k[1] for x in curr_times_inds]
# curr_weekday_inds = [[x[0]+k[1], x[1]+k[1]] for x in curr_weekday_inds]
# print("matching dates/times")
# for s, e in zip(curr_num_inds_s, curr_num_inds_e):
# print(strRes[s:e])
# for ind in set(curr_times_inds):
# print(strRes[ind:ind+2])
# for ind in curr_weekday_inds:
# print(strRes[ind[0]:ind[1]])
# # def is_a_time():
# # if there is a am/pm keyword after the number
|
py | 7dff125a6fe2f5022f1ec90168e170c1ec750aeb | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import numpy as np
# import cv2
# import matplotlib.pyplot as plt
import sys
# import segmentation_models_pytorch as smp
import albumentations as albu
import torch
import time
from torch.autograd import Variable
import onnx
#384x512
#pth_path = '/home/pt/Desktop/code/matting/traindata/unet4/yxl_1/res18_yxl.pth'
# pth_path = 'D:/pengt/segmetation/4channels/Unet4/parameter/best_model.pth'
# onnx_out='D:/pengt/segmetation/4channels/Unet4/parameter/onnx_best_model.onnx'
model_ENCODER = 'timm-efficientnet-b0'# 'timm-efficientnet-b0' #'dpn68'#'resnet18' #'mobilenet_v2' #'resnet18'# 'resnet101' #'resnet50' 'resnet152' 101
model_path = '//SmartGo-Nas/pentao/code/4channels/parameter/seg_pytorch/%s/best_model_52_0.936.pth'%model_ENCODER
# onnx_out='D:/pengt/code/Cplus/onnx_model/deeplab/%s_384x640_new1.onnx'%model_ENCODER
onnx_out='D:/pengt/code/Cplus/onnx_model/deeplab1/%s_640x384.onnx'%model_ENCODER
# ENCODER= 'densenet121'#'vgg13' #timm-efficientnet-b0' #"mobilenet_v2"
# ENCODER_WEIGHTS = 'imagenet'
# CLASSES = ['person']
# ACTIVATION = 'sigmoid' # could be None for logits or 'softmax2d' for multicalss segmentation
# model = smp.FPN(
# encoder_name=ENCODER,
# encoder_weights=ENCODER_WEIGHTS,
# classes=len(CLASSES),
# activation=ACTIVATION,
# )
# model = smp.DeepLabV3Plus(
# encoder_name=model_ENCODER,
# encoder_weights=ENCODER_WEIGHTS,
# classes=len(CLASSES),
# activation=ACTIVATION,
# in_channels = 4,
# )
# model = torch.load(model_path,map_location=torch.device('cuda'))
model = torch.load(model_path)
model=model.cuda()
dummy_input = Variable(torch.randn(1, 4, 640 , 384))
# #dummy_input = torch.randn(1, 4, 320, 320, requires_grad=True)
model=model.cpu()
# dummy_input = Variable(torch.randn(1, 4, 480 , 640))
#dummy_input = torch.randn(1, 4, 320, 320, requires_grad=True)
model.eval()
print(model)
#torch.onnx.export(model, dummy_input, "/media/xingshi2/data/purning/network-slimming/Unet_resnet50.onnx", verbose=True)
#model1 = onnx.load("/media/xingshi2/data/purning/network-slimming/Unet_resnet50.onnx")
# Check that the IR is well formed
#onnx.checker.check_model(model1)
# Print a human readable representation of the graph
#onnx.helper.printable_graph(model1.graph)
#opset_version = model1.opset_import[0].version
# model.set_swish(memory_efficient=False)
torch.onnx.export(model, # model being run
dummy_input, # model input (or a tuple for multiple inputs)
onnx_out, # where to save the model (can be a file or file-like object)
export_params=True, # store the trained parameter weights inside the model file
opset_version=11,#12, # the onnx version to export the model to
verbose=True,
# do_constant_folding=True, # wether to execute constant folding for optimization
#input_names = ['final_conv'], # the model's input names
#output_names = ['final_conv'], # the model's output names
# dynamic_axes={'input' : {0 : 'batch_size'}, # variable lenght axes
# 'output' : {0 : 'batch_size'}}
)
|
py | 7dff1281bf916836489e24ec27dae1d1d40a704b |
from django.contrib.contenttypes.models import ContentType
from django.core.urlresolvers import reverse
from django.db import transaction
from django.db.models import Q
from django.forms import ModelChoiceField
from django.http import QueryDict
from django.template import loader
from django.utils.decorators import method_decorator
from django.utils.encoding import smart_text
from django.utils.translation import ugettext_lazy as _
from django.views.decorators.csrf import csrf_protect
from xadmin.filters import FILTER_PREFIX, SEARCH_VAR
from xadmin.plugins.relate import RELATE_PREFIX
from xadmin.plugins.utils import get_context_dict
from xadmin.sites import site
from xadmin.views import ModelAdminView, BaseAdminPlugin, ListAdminView
from xadmin.views.list import COL_LIST_VAR, ORDER_VAR
from xadmin.views.dashboard import widget_manager, BaseWidget, PartialBaseWidget
from xadmin.models import Bookmark
csrf_protect_m = method_decorator(csrf_protect)
class BookmarkPlugin(BaseAdminPlugin):
# [{'title': "Female", 'query': {'gender': True}, 'order': ('-age'), 'cols': ('first_name', 'age', 'phones'), 'search': 'Tom'}]
list_bookmarks = []
show_bookmarks = True
def has_change_permission(self, obj=None):
if not obj or self.user.is_superuser:
return True
else:
return obj.user == self.user
def get_context(self, context):
if not self.show_bookmarks:
return context
bookmarks = []
current_qs = '&'.join([
'%s=%s' % (k, v)
for k, v in sorted(filter(
lambda i: bool(i[1] and (
i[0] in (COL_LIST_VAR, ORDER_VAR, SEARCH_VAR)
or i[0].startswith(FILTER_PREFIX)
or i[0].startswith(RELATE_PREFIX)
)),
self.request.GET.items()
))
])
model_info = (self.opts.app_label, self.opts.model_name)
has_selected = False
menu_title = _(u"Bookmark")
list_base_url = reverse('xadmin:%s_%s_changelist' %
model_info, current_app=self.admin_site.name)
# local bookmarks
for bk in self.list_bookmarks:
title = bk['title']
params = dict([
(FILTER_PREFIX + k, v)
for (k, v) in bk['query'].items()
])
if 'order' in bk:
params[ORDER_VAR] = '.'.join(bk['order'])
if 'cols' in bk:
params[COL_LIST_VAR] = '.'.join(bk['cols'])
if 'search' in bk:
params[SEARCH_VAR] = bk['search']
def check_item(i):
return bool(i[1]) or i[1] == False
bk_qs = '&'.join([
'%s=%s' % (k, v)
for k, v in sorted(filter(check_item, params.items()))
])
url = list_base_url + '?' + bk_qs
selected = (current_qs == bk_qs)
bookmarks.append(
{'title': title, 'selected': selected, 'url': url})
if selected:
menu_title = title
has_selected = True
content_type = ContentType.objects.get_for_model(self.model)
bk_model_info = (Bookmark._meta.app_label, Bookmark._meta.model_name)
bookmarks_queryset = Bookmark.objects.filter(
content_type=content_type,
url_name='xadmin:%s_%s_changelist' % model_info
).filter(Q(user=self.user) | Q(is_share=True))
for bk in bookmarks_queryset:
selected = (current_qs == bk.query)
if self.has_change_permission(bk):
change_or_detail = 'change'
else:
change_or_detail = 'detail'
bookmarks.append({'title': bk.title, 'selected': selected, 'url': bk.url, 'edit_url':
reverse('xadmin:%s_%s_%s' % (bk_model_info[0], bk_model_info[1], change_or_detail),
args=(bk.id,))})
if selected:
menu_title = bk.title
has_selected = True
post_url = reverse('xadmin:%s_%s_bookmark' % model_info,
current_app=self.admin_site.name)
new_context = {
'bk_menu_title': menu_title,
'bk_bookmarks': bookmarks,
'bk_current_qs': current_qs,
'bk_has_selected': has_selected,
'bk_list_base_url': list_base_url,
'bk_post_url': post_url,
'has_add_permission_bookmark': self.admin_view.request.user.has_perm('xadmin.add_bookmark'),
'has_change_permission_bookmark': self.admin_view.request.user.has_perm('xadmin.change_bookmark')
}
context.update(new_context)
return context
# Media
def get_media(self, media):
return media + self.vendor('xadmin.plugin.bookmark.js')
# Block Views
def block_nav_menu(self, context, nodes):
if self.show_bookmarks:
nodes.insert(0, loader.render_to_string('xadmin/blocks/model_list.nav_menu.bookmarks.html',
context=get_context_dict(context)))
class BookmarkView(ModelAdminView):
@csrf_protect_m
@transaction.atomic
def post(self, request):
model_info = (self.opts.app_label, self.opts.model_name)
url_name = 'xadmin:%s_%s_changelist' % model_info
bookmark = Bookmark(
content_type=ContentType.objects.get_for_model(self.model),
title=request.POST[
'title'], user=self.user, query=request.POST.get('query', ''),
is_share=request.POST.get('is_share', 0), url_name=url_name)
bookmark.save()
content = {'title': bookmark.title, 'url': bookmark.url}
return self.render_response(content)
class BookmarkAdmin(object):
model_icon = 'fa fa-book'
list_display = ('title', 'users', 'url_name', 'query')
list_display_links = ('title',)
user_fields = ['users']
hidden_menu = True
def queryset(self):
if self.user.is_superuser:
return Bookmark.objects.all()
return Bookmark.objects.filter(Q(user=self.user) | Q(is_share=True))
def get_list_display(self):
list_display = super(BookmarkAdmin, self).get_list_display()
if not self.user.is_superuser:
list_display.remove('users')
return list_display
def has_change_permission(self, obj=None):
if not obj or self.user.is_superuser:
return True
else:
return obj.user == self.user
@widget_manager.register
class BookmarkWidget(PartialBaseWidget):
widget_type = _('bookmark')
widget_icon = 'fa fa-bookmark'
description = _(
'Bookmark Widget, can show users\'s bookmark list data in widget.')
template = "xadmin/widgets/list.html"
bookmark = ModelChoiceField(
label=_('Bookmark'), queryset=Bookmark.objects.all(), required=False)
def setup(self):
BaseWidget.setup(self)
bookmark = self.cleaned_data['bookmark']
model = bookmark.content_type.model_class()
data = QueryDict(bookmark.query)
self.bookmark = bookmark
if not self.title:
self.title = smart_text(bookmark)
req = self.make_get_request("", data.items())
self.list_view = self.get_view_class(
ListAdminView, model, list_per_page=10, list_editable=[])(req)
def has_perm(self):
return True
def context(self, context):
list_view = self.list_view
list_view.make_result_list()
base_fields = list_view.base_list_display
if len(base_fields) > 5:
base_fields = base_fields[0:5]
context['result_headers'] = [c for c in list_view.result_headers(
).cells if c.field_name in base_fields]
context['results'] = [
[o for i, o in enumerate(filter(
lambda c: c.field_name in base_fields,
r.cells
))]
for r in list_view.results()
]
context['result_count'] = list_view.result_count
context['page_url'] = self.bookmark.url
site.register(Bookmark, BookmarkAdmin)
site.register_plugin(BookmarkPlugin, ListAdminView)
site.register_modelview(r'^bookmark/$', BookmarkView, name='%s_%s_bookmark')
|
py | 7dff143b195f1506ea18e51702cefeac04dcaba5 | ##
# This software was developed and / or modified by Raytheon Company,
# pursuant to Contract DG133W-05-CQ-1067 with the US Government.
#
# U.S. EXPORT CONTROLLED TECHNICAL DATA
# This software product contains export-restricted data whose
# export/transfer/disclosure is restricted by U.S. law. Dissemination
# to non-U.S. persons whether in the United States or abroad requires
# an export license or other authorization.
#
# Contractor Name: Raytheon Company
# Contractor Address: 6825 Pine Street, Suite 340
# Mail Stop B8
# Omaha, NE 68106
# 402.291.0100
#
# See the AWIPS II Master Rights File ("Master Rights File.pdf") for
# further licensing information.
##
# File auto-generated by PythonFileGenerator
__all__ = [
'ClusterMembersResponse',
'ContextsResponse',
'StatusResponse'
]
from ClusterMembersResponse import ClusterMembersResponse
from ContextsResponse import ContextsResponse
from StatusResponse import StatusResponse
|
py | 7dff150e39361cafeb16ccb6ff9f707428262ac4 | # Copyright The PyTorch Lightning team.
#
# 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.
from typing import Tuple
import torch
from torch import Tensor
from torchmetrics.utilities.data import to_categorical
from torchmetrics.utilities.distributed import reduce
def _stat_scores(
preds: Tensor,
target: Tensor,
class_index: int,
argmax_dim: int = 1,
) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]:
"""
Calculates the number of true positive, false positive, true negative
and false negative for a specific class
Args:
pred: prediction tensor
target: target tensor
class_index: class to calculate over
argmax_dim: if pred is a tensor of probabilities, this indicates the
axis the argmax transformation will be applied over
Return:
True Positive, False Positive, True Negative, False Negative, Support
Example:
>>> x = torch.tensor([1, 2, 3])
>>> y = torch.tensor([0, 2, 3])
>>> tp, fp, tn, fn, sup = _stat_scores(x, y, class_index=1)
>>> tp, fp, tn, fn, sup
(tensor(0), tensor(1), tensor(2), tensor(0), tensor(0))
"""
if preds.ndim == target.ndim + 1:
preds = to_categorical(preds, argmax_dim=argmax_dim)
tp = ((preds == class_index) * (target == class_index)).to(torch.long).sum()
fp = ((preds == class_index) * (target != class_index)).to(torch.long).sum()
tn = ((preds != class_index) * (target != class_index)).to(torch.long).sum()
fn = ((preds != class_index) * (target == class_index)).to(torch.long).sum()
sup = (target == class_index).to(torch.long).sum()
return tp, fp, tn, fn, sup
def dice_score(
pred: Tensor,
target: Tensor,
bg: bool = False,
nan_score: float = 0.0,
no_fg_score: float = 0.0,
reduction: str = 'elementwise_mean',
) -> Tensor:
"""
Compute dice score from prediction scores
Args:
pred: estimated probabilities
target: ground-truth labels
bg: whether to also compute dice for the background
nan_score: score to return, if a NaN occurs during computation
no_fg_score: score to return, if no foreground pixel was found in target
reduction: a method to reduce metric score over labels.
- ``'elementwise_mean'``: takes the mean (default)
- ``'sum'``: takes the sum
- ``'none'``: no reduction will be applied
Return:
Tensor containing dice score
Example:
>>> pred = torch.tensor([[0.85, 0.05, 0.05, 0.05],
... [0.05, 0.85, 0.05, 0.05],
... [0.05, 0.05, 0.85, 0.05],
... [0.05, 0.05, 0.05, 0.85]])
>>> target = torch.tensor([0, 1, 3, 2])
>>> dice_score(pred, target)
tensor(0.3333)
"""
num_classes = pred.shape[1]
bg = (1 - int(bool(bg)))
scores = torch.zeros(num_classes - bg, device=pred.device, dtype=torch.float32)
for i in range(bg, num_classes):
if not (target == i).any():
# no foreground class
scores[i - bg] += no_fg_score
continue
# TODO: rewrite to use general `stat_scores`
tp, fp, tn, fn, sup = _stat_scores(preds=pred, target=target, class_index=i)
denom = (2 * tp + fp + fn).to(torch.float)
# nan result
score_cls = (2 * tp).to(torch.float) / denom if torch.is_nonzero(denom) else nan_score
scores[i - bg] += score_cls
return reduce(scores, reduction=reduction)
|
py | 7dff1521124e48466ca047fe5469e3696b8dc7e0 | """
https://pythontutor.com/visualize.html#code=class%20Solution%3A%0A%20%20%20%20def%20duplicateZeros%28self,%20arr%29%20-%3E%20None%3A%0A%20%20%20%20%20%20%20%20%22%22%22%0A%20%20%20%20%20%20%20%20Do%20not%20return%20anything,%20modify%20arr%20in-place%20instead.%0A%20%20%20%20%20%20%20%20%22%22%22%0A%20%20%20%20%20%20%20%20possible_dups%20%3D%200%0A%20%20%20%20%20%20%20%20length_%20%3D%20len%28arr%29%20-%201%0A%0A%20%20%20%20%20%20%20%20%23%20Find%20the%20number%20of%20zeros%20to%20be%20duplicated%0A%20%20%20%20%20%20%20%20for%20left%20in%20range%28length_%20%2B%201%29%3A%0A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20Stop%20when%20left%20points%20beyond%20the%20last%20element%20in%20the%20original%20list%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20which%20would%20be%20part%20of%20the%20modified%20list%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20left%20%3E%20length_%20-%20possible_dups%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20break%0A%0A%20%20%20%20%20%20%20%20%20%20%20%20%23%20Count%20the%20zeros%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20arr%5Bleft%5D%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20Edge%20case%3A%20This%20zero%20can't%20be%20duplicated.%20We%20have%20no%20more%20space,%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20as%20left%20is%20pointing%20to%20the%20last%20element%20which%20could%20be%20included%20%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20if%20left%20%3D%3D%20length_%20-%20possible_dups%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20arr%5Blength_%5D%20%3D%200%20%23%20For%20this%20zero%20we%20just%20copy%20it%20without%20duplication.%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20length_%20-%3D%201%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20possible_dups%20%2B%3D%201%0A%0A%20%20%20%20%20%20%20%20%23%20Start%20backwards%20from%20the%20last%20element%20which%20would%20be%20part%20of%20new%20list.%0A%20%20%20%20%20%20%20%20last%20%3D%20length_%20-%20possible_dups%0A%0A%20%20%20%20%20%20%20%20%23%20Copy%20zero%20twice,%20and%20non%20zero%20once.%0A%20%20%20%20%20%20%20%20for%20i%20in%20range%28last,%20-1,%20-1%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20arr%5Bi%5D%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20arr%5Bi%20%2B%20possible_dups%5D%20%3D%200%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20possible_dups%20-%3D%201%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20arr%5Bi%20%2B%20possible_dups%5D%20%3D%200%0A%20%20%20%20%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20arr%5Bi%20%2B%20possible_dups%5D%20%3D%20arr%5Bi%5D%0A%0A%0As%20%3D%20Solution%28%29%0As.duplicateZeros%28%5B1,0,2,3,0,4,5,0%5D%29%0A%20%20%20%20%20%20%20%20%20%20%20%20&cumulative=false&curInstr=8&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false
Why backwards?
If we would start shifting from left to right, then we would be overwriting elements before we have had the chance to shift them
that is why we go backwards instead.
We make sure we have shifted out an element before we shift another one into its original position.
What is the correct shift distance?
The duplication of a zero pushes all elements to the right of it by one.
This means also that every element is shifted to the right as many times as there are zeroes to the left of it.
E.g. in the array [1,0,2,0,3] , 1 will not move, 2 will shift one position and 3 will shift two positions.
As we go backwards, every time we bypass a zero (and duplicate it), the shift distance decreases for the elements we haven't shifted yet, because there is one less zero in front of them.
Why the < n checks?
Shifts push some of the elements out of the array. We do the < n checks to make sure we write down only elements that are shifted to a valid position inside the array and we ignore the ones falling off the end
"""
class Solution:
def duplicateZeros(self, arr: List[int]) -> None:
"""
Do not return anything, modify arr in-place instead.
"""
zeros = 0
for i in range(len(arr)):
if arr[i] == 0:
zeros += 1
for i in range(len(arr) - 1, -1 ,-1):
if i + zeros < len(arr):
arr[i + zeros] == arr[i]
if arr[i] == 0:
zeros -= 1
if i + zeros < len(arr):
arr[i + zeros] = 0
|
py | 7dff15added57911df8726274ae5998c32a98e61 | import unittest
import numpy as np
from pma import can_solver
from openravepy import Environment, matrixFromAxisAngle
from core.util_classes.viewer import OpenRAVEViewer
from core.util_classes.openrave_body import OpenRAVEBody
from core.util_classes.robots import PR2
from core.util_classes import items, pr2_sampling, matrix, param_setup
from core.util_classes.param_setup import ParamSetup
from core.internal_repr import parameter
import time
class TestSampling(unittest.TestCase):
def test_sample_ee_from_target(self):
solver = can_solver.CanSolver()
env = ParamSetup.setup_env()
# env.SetViewer('qtcoin')
target = ParamSetup.setup_target()
target.value = np.array([[0,0,0]]).T
target.rotation = np.array([[1.1,.3,0]]).T
dummy_targ_geom = items.BlueCan(0.04, 0.25)
target_body = OpenRAVEBody(env, target.name, dummy_targ_geom)
target_body.set_pose(target.value.flatten(), target.rotation.flatten())
target_body.set_transparency(.7)
robot = ParamSetup.setup_pr2()
robot_body = OpenRAVEBody(env, robot.name, robot.geom)
robot_body.set_transparency(.7)
robot_body.set_pose(robot.pose.flatten())
dof_value_map = {"backHeight": robot.backHeight,
"lArmPose": robot.lArmPose.flatten(),
"lGripper": robot.lGripper,
"rArmPose": robot.rArmPose.flatten(),
"rGripper": robot.rGripper}
robot_body.set_dof(dof_value_map)
dummy_ee_pose_geom = items.GreenCan(.03,.3)
ee_list = list(enumerate(pr2_sampling.get_ee_from_target(target.value, target.rotation)))
for ee_pose in ee_list:
ee_pos, ee_rot = ee_pose[1]
body = OpenRAVEBody(env, "dummy"+str(ee_pose[0]), dummy_ee_pose_geom)
body.set_pose(ee_pos, ee_rot)
body.set_transparency(.9)
def test_closest_arm_pose(self):
env = ParamSetup.setup_env()
# env.SetViewer('qtcoin')
can = ParamSetup.setup_blue_can()
robot = ParamSetup.setup_pr2()
can.pose = np.array([[0,-.2,.8]]).T
can_body = OpenRAVEBody(env, can.name, can.geom)
can_body.set_pose(can.pose.flatten(), can.rotation.flatten())
can_body.set_transparency(.7)
robot.pose = np.array([[-.5,0,0]]).T
robot_body = OpenRAVEBody(env, robot.name, robot.geom)
robot_body.set_transparency(.7)
robot_body.set_pose(robot.pose.flatten())
dof_value_map = {"backHeight": robot.backHeight,
"lArmPose": robot.lArmPose.flatten(),
"lGripper": robot.lGripper,
"rArmPose": robot.rArmPose.flatten(),
"rGripper": robot.rGripper}
robot_body.set_dof(dof_value_map)
can_trans = OpenRAVEBody.transform_from_obj_pose(can.pose, can.rotation)
rot_mat = matrixFromAxisAngle([0, np.pi/2, 0])
rot_mat = can_trans[:3, :3].dot(rot_mat[:3, :3])
can_trans[:3, :3] = rot_mat
torso_pose, arm_pose = pr2_sampling.get_torso_arm_ik(robot_body, can_trans, robot.rArmPose)
dof_value_map = {"backHeight": robot.backHeight,
"lArmPose": robot.lArmPose.flatten(),
"lGripper": robot.lGripper,
"rArmPose": robot.rArmPose.flatten(),
"rGripper": robot.rGripper}
robot_body.set_dof(dof_value_map)
# import ipdb; ipdb.set_trace()
|
py | 7dff1675a97ab9f8efb2cf1f13cabf4faaf3729b | import logging
import random
from ozpcenter.recommend import recommend_utils
from ozpcenter.recommend.recommend_utils import Direction
from ozpcenter.recommend.recommend_utils import FastNoSuchElementException
from plugins.plugin_manager import system_has_access_control
logger = logging.getLogger('ozp-center.' + str(__name__))
class Pipe(object):
"""
<S, E>
"""
def __init__(self):
"""
Initialize Pipe
Args:
starts: Start of the Pipe
"""
self.starts = None
self.available = False
self.current_end = None
self.next_end = None
def set_starts(self, starts):
"""
Args:
starts: iterable of s objects to the head (start) of pipe
"""
self.starts = starts
def next(self):
"""
Return one E Object
"""
if self.available:
self.available = False
self.current_end = self.next_end
return self.current_end
else:
self.current_end = self.process_next_start()
return self.current_end
def has_next(self):
"""
Return Boolean
"""
if self.available:
return True
else:
try:
self.next_end = self.process_next_start()
self.available = True
return self.available
except IndexError as err: # TODO: Fix to RuntimeError
self.available = False
return self.available
except Exception as err: # NoSuchElementException
raise err
def process_next_start(self):
"""
Returns E
Raise:
NoSuchElementException
"""
raise NotImplementedError("Need to implement in subclasses")
def reset(self):
if isinstance(self.starts, self.__class__):
self.starts.reset()
self.next_end = None
self.current_end = None
self.available = False
def __str__(self):
default_keys = ['starts', 'available', 'current_end', 'next_end']
instance_vars = {}
variables = vars(self)
for variable_key in variables:
variable_value = variables[variable_key]
if variable_key not in default_keys:
if callable(variable_value):
variable_value = variable_value.__class__
if not variable_key.startswith('_'):
instance_vars[variable_key] = variable_value
variables_string = ', '.join(['{}:{}'.format(key, instance_vars[key]) for key in instance_vars])
output = '{}({})'.format(self.__class__.__name__, variables_string)
return output
class MetaPipe(Pipe):
def get_pipes(self):
raise NotImplementedError("Need to implement in subclasses")
def reset(self):
for pipe in self.get_pipes():
pipe.reset()
super().reset()
class AsPipe(MetaPipe):
def __init__(self, name, pipe):
super().__init__()
self.name = name
self.pipe = pipe
def set_starts(self, starts):
"""
Args:
starts: iterable of s objects to the head (start) of pipe
"""
self.pipe.set_starts(starts)
self.starts = starts
def get_current_end(self):
return self.current_end
def get_name(self):
return self.name
def process_next_start(self):
return self.pipe.next()
def get_pipes(self):
return [self.pipe]
class VerticesVerticesPipe(Pipe):
def __init__(self, direction, *labels):
super().__init__()
# Super
self.direction = direction
self.labels = labels
self.next_end = recommend_utils.EmptyIterator()
def process_next_start(self):
"""
Start at Vertex, return Vertex
"""
while True:
if self.next_end.has_next():
try:
current_edge = self.next_end.next()
if self.direction == Direction.OUT:
return current_edge.out_vertex # Edge
elif self.direction == Direction.IN:
return current_edge.in_vertex
else:
raise Exception('Need to implement')
except FastNoSuchElementException:
pass
else:
current_vertex = self.starts.next()
edges_iterator = current_vertex.get_edges_iterator(self.direction, self.labels)
self.next_end = edges_iterator
class VerticesEdgesPipe(Pipe):
def __init__(self, direction, *labels):
super().__init__()
# Super
self.direction = direction
self.labels = labels
self.next_end = recommend_utils.EmptyIterator()
def process_next_start(self):
"""
Start at Vertex, return Vertex
"""
while True:
if self.next_end.has_next():
try:
current_edge = self.next_end.next()
if self.direction == Direction.OUT:
return current_edge # Edge
elif self.direction == Direction.IN:
return current_edge
else:
raise Exception('Need to implement')
except FastNoSuchElementException:
pass
else:
current_vertex = self.starts.next()
edges_iterator = current_vertex.get_edges_iterator(self.direction, self.labels)
self.next_end = edges_iterator
class EdgesVerticesPipe(Pipe):
def __init__(self, direction):
super().__init__()
# Super
self.direction = direction
def process_next_start(self):
"""
Start at Edge, return Vertex
"""
pass
class CapitalizePipe(Pipe):
def __init__(self):
super().__init__()
def process_next_start(self):
"""
CapitalizePipe each string object
"""
start = self.starts.next().upper()
return start
class SideEffectPipe(Pipe):
def __init__(self, function):
super().__init__()
self.function = function
def process_next_start(self):
"""
SideEffectPipe
"""
start = self.starts.next()
self.function(start)
return start
class LenPipe(Pipe):
def __init__(self):
super().__init__()
def process_next_start(self):
"""
Find length each object
"""
start = len(self.starts.next())
return start
class ListingPostSecurityMarkingCheckPipe(Pipe):
def __init__(self, username):
super().__init__()
self.username = username
def process_next_start(self):
"""
execute security_marking check on each listing
"""
while True:
listing = self.starts.next()
if not listing.security_marking:
logger.debug('Listing {0!s} has no security_marking'.format(listing.title))
if system_has_access_control(self.username, listing.security_marking):
return listing
class JitterPipe(Pipe):
def __init__(self):
super().__init__()
self.count = 0
self.non_random_beginning_count = 3
self.upper_limit = 7
def process_next_start(self):
"""
execute on each listing
"""
while True:
self.count = self.count + 1
listing = self.starts.next()
if self.count <= self.non_random_beginning_count:
return listing
random_number = random.randint(0, 10)
if random_number <= self.upper_limit:
return listing
class ListingDictPostSecurityMarkingCheckPipe(Pipe):
def __init__(self, username, featured=False):
super().__init__()
self.username = username
self.featured = featured
def process_next_start(self):
"""
execute security_marking check on each listing
"""
while True:
listing = self.starts.next()
if not listing['security_marking']:
logger.debug('Listing {0!s} has no security_marking'.format(listing['title']))
else:
if self.featured:
if listing['is_featured'] is True:
if system_has_access_control(self.username, listing['security_marking']):
return listing
else:
if system_has_access_control(self.username, listing['security_marking']):
return listing
class LimitPipe(Pipe):
def __init__(self, limit_number):
super().__init__()
self._count = 1
self.limit_number = limit_number
def process_next_start(self):
"""
Limit number of items
"""
while True:
if self._count > self.limit_number:
raise FastNoSuchElementException()
else:
current_item = self.starts.next()
self._count = self._count + 1
return current_item
class DistinctPipe(Pipe):
def __init__(self):
super().__init__()
self._items = set()
def process_next_start(self):
"""
Limit number of items
"""
while True:
current_item = self.starts.next()
if current_item not in self._items:
self._items.add(current_item)
return current_item
class ExcludePipe(Pipe):
def __init__(self, object_list):
super().__init__()
self._items = set()
for current_object in object_list:
self._items.add(current_object)
def process_next_start(self):
"""
Limit number of items
"""
while True:
current_item = self.starts.next()
if current_item not in self._items:
return current_item
class ExcludeIdsPipe(Pipe):
def __init__(self, object_list):
super().__init__()
self._items = set()
for current_object in object_list:
self._items.add(current_object)
def process_next_start(self):
"""
Limit number of items
"""
while True:
current_element = self.starts.next()
current_element_id = current_element.id
if current_element_id not in self._items:
return current_element
class GraphVertexPipe(Pipe):
"""
Start of Graph to vertex flow
"""
def __init__(self):
super().__init__()
def process_next_start(self):
"""
CapitalizePipe each string object
"""
current_vertex = self.starts.next()
return current_vertex
class ElementIdPipe(Pipe):
"""
Start of Graph to vertex flow
"""
def __init__(self):
super().__init__()
def process_next_start(self):
"""
CapitalizePipe each string object
"""
current_vertex = self.starts.next()
return current_vertex.id
class ElementPropertiesPipe(Pipe):
"""
Start of Graph to vertex flow
"""
def __init__(self, internal=False):
super().__init__()
self.internal = internal
def process_next_start(self):
"""
CapitalizePipe each string object
"""
current_vertex = self.starts.next()
vertex_properties = current_vertex.properties
if self.internal:
vertex_properties['_id'] = current_vertex.id
vertex_properties['_label'] = current_vertex.label
return vertex_properties
class ElementHasPipe(Pipe):
"""
ElementHasPipe Pipe
"""
def __init__(self, label, key=None, predicate='EQUALS', value=None):
super().__init__()
def process_next_start(self):
"""
Element Has each string object
"""
current_vertex = self.starts.next()
return current_vertex
class DictKeyPipe(Pipe):
"""
DictKeyPipe Pipe
"""
def __init__(self, key):
super().__init__()
self.key = key
def process_next_start(self):
"""
DictKeyPipe
"""
current_dict = self.starts.next()
if self.key in current_dict:
return current_dict[self.key]
class EachKeyPipe(Pipe):
"""
EachKeyPipe Pipe
"""
def __init__(self, key):
super().__init__()
self.key = key
self.next_end = recommend_utils.EmptyIterator()
def process_next_start(self):
"""
EachKeyPipe
"""
while True:
if self.next_end.has_next():
try:
while True:
return self.next_end.next()
except recommend_utils.FastNoSuchElementException:
# Ignore FastNoSuchElementException
pass
else:
current_dict = self.starts.next()
if self.key in current_dict:
current_list = current_dict[self.key]
if current_list:
self.next_end = recommend_utils.ListIterator(current_list)
|
py | 7dff171a5eb13868d248fa1c4549f6e3efc762d7 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import annotations
from typing import ByteString, Callable, Dict, List, Optional, Set, Union
import marshal
import enum
import io
import re
import uuid
import zlib
import os
import os.path
import contextlib
import dataclasses
import sys
from importlib.util import MAGIC_NUMBER
from refinery.units.formats.archive import Arg, ArchiveUnit
from refinery.units.pattern.carve import carve
from refinery.lib.structures import EOF, MemoryFile, StreamDetour, Struct, StructReader
from refinery.lib.tools import NoLogging
from Crypto.Cipher import AES
class Unmarshal(enum.IntEnum):
No = 0
Yes = 1
YesAndDecompile = 2
def version2tuple(version: str):
return tuple(int(k, 10) for k in re.fullmatch(R'^(\d+\.\d+(?:\.\d+)?)(.*)$', version).group(1).split('.'))
def decompress_peek(buffer, size=512) -> Optional[bytes]:
try:
return zlib.decompressobj().decompress(buffer[:size])
except zlib.error:
return None
def decompile_buffer(buffer: ByteString, file_name: str) -> ByteString:
code_objects = {}
sys_stderr = sys.stderr
sys.stderr = open(os.devnull, 'w')
try:
version, timestamp, magic_int, codez, is_pypy, _, _ = \
xtpyi._xdis.load.load_module_from_file_object(MemoryFile(buffer), file_name, code_objects)
finally:
sys.stderr.close()
sys.stderr = sys_stderr
if not isinstance(codez, list):
codez = [codez]
errors = ''
python = ''
for code in codez:
for name, engine in {
'decompyle3': xtpyi._decompyle3,
'uncompyle6': xtpyi._uncompyle6,
}.items():
with io.StringIO(newline='') as output, NoLogging(NoLogging.Mode.ALL):
try:
engine.main.decompile(
version,
code,
output,
timestamp=timestamp,
code_objects=code_objects,
is_pypy=is_pypy,
magic_int=magic_int,
)
except Exception as E:
errors += '\n'.join(F'# {line}' for line in (
F'Error while decompiling with {name}:', *str(E).splitlines(True)))
errors += '\n'
else:
python = output.getvalue()
break
if python:
return python.encode(xtpyi.codec)
embedded = bytes(buffer | carve('printable', single=True))
if len(buffer) - len(embedded) < 0x20:
return embedded
disassembly = MemoryFile()
with io.TextIOWrapper(disassembly, xtpyi.codec, newline='\n') as output:
output.write(errors)
output.write('# Generating Disassembly:\n\n')
for code in codez:
instructions = list(xtpyi._xdis.std.Bytecode(code))
width_offset = max(len(str(i.offset)) for i in instructions)
for i in instructions:
opname = i.opname.replace('_', '.').lower()
offset = F'{i.offset:0{width_offset}d}'
output.write(F'# {offset:>5} {opname:<25} {i.argrepr}\n')
output.write('\n')
return disassembly.getbuffer()
class PiType(bytes, enum.Enum):
BINARY = B'b' # noqa / binary
DEPENDENCY = B'd' # noqa / runtime option
PYZ = B'z' # noqa / zlib (pyz) - frozen Python code
PACKAGE = B'M' # noqa / Python package (__init__.py)
MODULE = B'm' # noqa / Python module
SOURCE = B's' # noqa / Python script (v3)
DATA = B'x' # noqa / data
RUNTIME_OPTION = B'o' # noqa / runtime option
SPLASH = B'l' # noqa / splash resources
UNKNOWN = B'uk' # noqa
DECOMPILED = B'dc' # noqa
USERCODE = B'uc' # noqa
ENCRYPTED = B'ec' # noqa
class PzType(enum.IntEnum):
MODULE = 0
PKG = 1
DATA = 2
@dataclasses.dataclass
class PiMeta:
type: PiType
name: str
data: Union[Callable[[], ByteString], ByteString]
def unpack(self) -> ByteString:
if callable(self.data):
self.data = self.data()
return self.data
def make_decompiled_item(name: str, data: ByteString, *magics) -> PiMeta:
def extract(data=data, magics=magics):
error = None
if any(data[:4] == m[:4] for m in magics):
return decompile_buffer(data, name)
for magic in magics:
try:
return decompile_buffer(magic + data, name)
except Exception as exception:
error = exception
return '\n'.join(F'# {line}'
for line in str(error).splitlines(True)).encode(xtpyi.codec)
return PiMeta(PiType.DECOMPILED, F'{name}.py', extract)
class PYZ(Struct):
MagicSignature = B'PYZ\0'
def __init__(self, reader: StructReader, version: str):
reader.bigendian = True
self.base = reader.tell()
signature = reader.read(4)
if signature != self.MagicSignature:
raise ValueError('invalid magic')
magic = bytes(reader.read(4))
with contextlib.suppress(KeyError):
version = xtpyi._xdis.magics.versions[magic]
vtuple = version2tuple(version)
padding_size = 4
if vtuple >= (3, 3):
padding_size += 4
if vtuple >= (3, 7):
padding_size += 4
self.version = version
self.magic = magic + padding_size * b'\0'
self.toc_offset = reader.i32()
self.reader = reader
self.entries: List[PiMeta] = []
def unpack(self, decompile: bool, key: Optional[bytes] = None) -> bool:
with StreamDetour(self.reader, self.base + self.toc_offset):
toc_data = self.reader.read()
try:
toc = marshal.loads(toc_data)
except Exception as error:
if MAGIC_NUMBER != self.magic[:4]:
_ord = xtpyi._xdis.marsh.Ord
xtpyi._xdis.marsh.Ord = ord # monkey-patch workaround for bug in xdis
try:
toc = xtpyi._xdis.marsh.load(
MemoryFile(self.data), self.version)
except Exception:
pass
else:
error = None
finally:
xtpyi._xdis.marsh.Ord = _ord
if error is not None:
raise error
if isinstance(toc, list):
try:
toc = dict(toc)
except Exception as error:
self.entries = []
self.error = error
return
failures = 0
attempts = len(toc)
for name, (pzt, offset, length) in toc.items():
try:
name: str
name = name.decode('utf-8')
except AttributeError:
pass
try:
pzt = PzType(pzt)
except Exception:
pzt = PzType.DATA
name = name.replace('.', '/')
if pzt is PzType.PKG:
name = F'{name}/__init__'
with StreamDetour(self.reader, self.base + offset):
data = self.reader.read(length)
if key:
def decompressed(data=data):
cipher = AES.new(key, AES.MODE_CFB, bytes(data[:0x10]))
return zlib.decompress(cipher.decrypt(data[0x10:]))
elif decompress_peek(data):
def decompressed(data=data):
return zlib.decompress(data)
else:
failures += 1
continue
if decompile and pzt in (PzType.MODULE, PzType.PKG):
def decompiled(data=data, name=name, magic=self.magic):
data = decompressed(data)
if data[:4] != magic[:4]:
data = magic + data
return decompile_buffer(data, name)
self.entries.append(PiMeta(PiType.DECOMPILED, F'{name}.py', decompiled))
name = F'{name}.pyc'
type = PiType.SOURCE
else:
type = PiType.DATA
self.entries.append(PiMeta(type, name, decompressed))
if key:
if failures >= 6:
xtpyi.logger.warning(F'pyz decompression failed for {failures-5} additional items')
return True
elif failures > 0.7 * attempts:
self.entries.clear()
return False
else:
return True
class PiTOCEntry(Struct):
def __init__(self, reader: StructReader):
reader.bigendian = True
entry_start_offset = reader.tell()
self.size_of_entry = reader.i32()
self.offset = reader.i32()
self.size_of_compressed_data = reader.i32()
self.size_od_uncompressed_data = reader.i32()
self.is_compressed = bool(reader.read_byte())
entry_type = bytes(reader.read(1))
name_length = self.size_of_entry - reader.tell() + entry_start_offset
if name_length > 0x1000:
raise RuntimeError(F'Refusing to process TOC entry with name of size {name_length}.')
name, *_ = bytes(reader.read(name_length)).partition(B'\0')
try:
name = name.decode('utf8', 'backslashreplace')
except Exception:
name = None
if not all(part.isprintable() for part in re.split('\\s*', name)):
raise RuntimeError('Refusing to process TOC entry with non-printable name.')
name = name or str(uuid.uuid4())
if entry_type == B'Z':
entry_type = B'z'
try:
self.type = PiType(entry_type)
except ValueError:
xtpyi.logger.error(F'unknown type {entry_type!r} in field {name}')
self.type = PiType.UNKNOWN
self.name = name
def __hash__(self):
return hash(self.name)
class PyInstallerArchiveEpilogue(Struct):
MagicSignature = bytes.fromhex('4D45490C0B0A0B0E')
def _read_libname(self, reader: StructReader) -> Optional[str]:
position = reader.tell()
try:
libname, t, rest = reader.read_bytes(64).partition(B'\0')
except EOF:
reader.seekset(position)
return None
try:
libname = libname.decode('utf8')
except Exception:
reader.seekset(position)
return None
if not t or any(rest) or len(rest) < 10 or not re.fullmatch(R'[\s!-~]+', libname):
reader.seekset(position)
return None
return libname
def __init__(self, reader: StructReader, offset: int, unmarshal: Unmarshal = Unmarshal.No):
reader.bigendian = True
reader.seekset(offset)
self.reader = reader
signature = reader.read_bytes(8)
if signature != self.MagicSignature:
raise ValueError(
F'offset 0x{offset:X} has invalid signature {signature.hex().upper()}; '
F'should be {self.MagicSignature.hex().upper()}')
self.size = reader.i32()
toc_offset = reader.i32()
toc_length = reader.i32()
self.py_version = '.'.join(str(reader.u32()))
self.py_libname = self._read_libname(reader)
self.offset = reader.tell() - self.size
self.toc: Dict[str, PiTOCEntry] = {}
toc_end = self.offset + toc_offset + toc_length
reader.seekset(self.offset + toc_offset)
while reader.tell() < toc_end:
try:
entry = PiTOCEntry(reader)
except EOF:
xtpyi.logger.warning('end of file while reading TOC')
break
except Exception as error:
xtpyi.logger.warning(F'unexpected error while reading TOC: {error!s}')
break
if entry.name in self.toc:
raise KeyError(F'duplicate name {entry.name}')
self.toc[entry.name] = entry
self.files: Dict[str, PiMeta] = {}
no_pyz_found = True
pyz_entries: Dict[str, PYZ] = {}
for entry in list(self.toc.values()):
if entry.type is not PiType.PYZ:
continue
no_pyz_found = False
name, xt = os.path.splitext(entry.name)
name_pyz = F'{name}.pyz'
if name == entry.name:
del self.toc[name]
self.toc[name_pyz] = entry
entry.name = name_pyz
reader.seekset(self.offset + entry.offset)
if entry.is_compressed:
data = self.extract(entry.name).unpack()
else:
data = reader
pyz_entries[name] = PYZ(data, self.py_version)
magics = {pyz.magic for pyz in pyz_entries.values()}
if not magics:
if not no_pyz_found:
xtpyi.logger.warning(
'no magic signature could be recovered from embedded pyzip archives; this is '
'unsual and means that there is no way to guess the missing magic for source '
'file entries and it will likely not be possible to decompile them.')
return
elif len(magics) > 1:
xtpyi.logger.warning('more than one magic signature was recovered; this is unusual.')
magics = list(magics)
keys: Set[bytes] = set()
for entry in self.toc.values():
extracted = self.extract(entry.name)
if entry.type not in (PiType.SOURCE, PiType.MODULE):
self.files[entry.name] = extracted
continue
data = extracted.unpack()
name, _ = os.path.splitext(extracted.name)
del self.files[extracted.name]
extracted.name = F'{name}.pyc'
self.files[extracted.name] = extracted
if len(magics) == 1 and data[:4] != magics[0]:
extracted.data = magics[0] + data
decompiled = make_decompiled_item(name, data, *magics)
if entry.type is PiType.SOURCE:
decompiled.type = PiType.USERCODE
self.files[F'{name}.py'] = decompiled
if name.endswith('crypto_key'):
for key in decompiled.unpack() | carve('string', decode=True):
if len(key) != 0x10:
continue
xtpyi.logger.info(F'found key: {key.decode(xtpyi.codec)}')
keys.add(key)
if unmarshal is Unmarshal.No:
return
if not keys:
key = None
else:
key = next(iter(keys))
for name, pyz in pyz_entries.items():
pyz.unpack(unmarshal is Unmarshal.YesAndDecompile, key)
for unpacked in pyz.entries:
unpacked.name = path = F'{name}/{unpacked.name}'
if path in self.files:
raise ValueError(F'duplicate file name: {path}')
self.files[path] = unpacked
def extract(self, name: str) -> PiMeta:
try:
return self.files[name]
except KeyError:
pass
entry = self.toc[name]
with StreamDetour(self.reader, self.offset + entry.offset):
data = self.reader.read(entry.size_of_compressed_data)
if entry.is_compressed:
def extracted(d=data): return zlib.decompress(d)
else:
extracted = data
result = PiMeta(entry.type, name, extracted)
self.files[name] = result
return result
class xtpyi(ArchiveUnit):
"""
Extracts and decompiles files from a Python Installer (aka PyInstaller) archive.
"""
def __init__(
self, *paths, list=False, join_path=False, drop_path=False, path=b'path', date=b'date',
user_code: Arg.Switch('-u', group='FILTER', help=(
'Extract only source code files from the root of the archive. These usually implement '
'the actual domain logic.')) = False,
unmarshal: Arg('-y', action='count', group='FILTER', help=(
'(DANGEROUS) Unmarshal embedded PYZ archives. Warning: Maliciously crafted packages can '
'potentially exploit this to execute code. It is advised to only use this option inside '
'an isolated environment. Specify twice to decompile unmarshalled Python bytecode.'
)) = 0
):
super().__init__(
*paths,
list=list, join_path=join_path, drop_path=drop_path, path=path, date=date,
unmarshal=unmarshal, user_code=user_code
)
@ArchiveUnit.Requires('xdis', optional=False)
def _xdis():
import xdis.load
import xdis.magics
import xdis.marsh
import xdis
A, B, C, *_ = sys.version_info
V = F'{A}.{B}.{C}'
if V not in xdis.magics.canonic_python_version:
xdis.magics.add_canonic_versions(V, F'{A}.{B}')
del A, B, C, V
import xdis.std
return xdis
@ArchiveUnit.Requires('uncompyle6', optional=False)
def _uncompyle6():
import uncompyle6
import uncompyle6.main
return uncompyle6
@ArchiveUnit.Requires('decompyle3', optional=False)
def _decompyle3():
import decompyle3
import decompyle3.main
return decompyle3
def unpack(self, data):
view = memoryview(data)
positions = [m.start() for m in re.finditer(re.escape(PyInstallerArchiveEpilogue.MagicSignature), view)]
mode = Unmarshal(min(2, int(self.args.unmarshal)))
self.log_debug(F'unmarshal mode: {mode.name}')
if not positions:
raise LookupError('unable to find PyInstaller signature')
if len(positions) > 2:
# first position is expected to be the sentinel value in the unpacker stub
width = max(len(F'{p:X}') for p in positions)
for position in positions:
self.log_info(F'magic signature found at offset 0x{position:0{width}X}')
self.log_warn(F'found {len(positions)-1} potential PyInstaller epilogue markers; using last one.')
archive = PyInstallerArchiveEpilogue(view, positions[-1], mode)
for name, file in archive.files.items():
if self.args.user_code:
if file.type != PiType.USERCODE:
continue
if name.startswith('pyiboot'):
continue
yield self._pack(name, None, file.data, type=file.type.name)
@classmethod
def handles(cls, data: ByteString) -> Optional[bool]:
return PyInstallerArchiveEpilogue.MagicSignature in data
|
py | 7dff1b94621f2587764b07281b8891e8c6eace03 | # Generated by Django 3.2.9 on 2021-12-01 10:07
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('photos', '0007_alter_image_image'),
]
operations = [
migrations.AlterField(
model_name='category',
name='id',
field=models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
),
migrations.AlterField(
model_name='image',
name='id',
field=models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
),
migrations.AlterField(
model_name='location',
name='id',
field=models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID'),
),
]
|
py | 7dff1c319a6c251f27c302ce9ee8aa3440ffc714 | """Interface to the liblzma compression library.
This module provides a class for reading and writing compressed files,
classes for incremental (de)compression, and convenience functions for
one-shot (de)compression.
These classes and functions support both the XZ and legacy LZMA
container formats, as well as raw compressed data streams.
"""
__all__ = [
"CHECK_NONE", "CHECK_CRC32", "CHECK_CRC64", "CHECK_SHA256",
"CHECK_ID_MAX", "CHECK_UNKNOWN",
"FILTER_LZMA1", "FILTER_LZMA2", "FILTER_DELTA", "FILTER_X86", "FILTER_IA64",
"FILTER_ARM", "FILTER_ARMTHUMB", "FILTER_POWERPC", "FILTER_SPARC",
"FORMAT_AUTO", "FORMAT_XZ", "FORMAT_ALONE", "FORMAT_RAW",
"MF_HC3", "MF_HC4", "MF_BT2", "MF_BT3", "MF_BT4",
"MODE_FAST", "MODE_NORMAL", "PRESET_DEFAULT", "PRESET_EXTREME",
"LZMACompressor", "LZMADecompressor", "LZMAFile", "LZMAError",
"open", "compress", "decompress", "is_check_supported",
]
import builtins
import io
from _lzma import *
from _lzma import _encode_filter_properties, _decode_filter_properties
import _compression
_MODE_CLOSED = 0
_MODE_READ = 1
# Value 2 no longer used
_MODE_WRITE = 3
class LZMAFile(_compression.BaseStream):
"""A file object providing transparent LZMA (de)compression.
An LZMAFile can act as a wrapper for an existing file object, or
refer directly to a named file on disk.
Note that LZMAFile provides a *binary* file interface - data read
is returned as bytes, and data to be written must be given as bytes.
"""
def __init__(self, filename=None, mode="r", *,
format=None, check=-1, preset=None, filters=None):
"""Open an LZMA-compressed file in binary mode.
filename can be either an actual file name (given as a str or
bytes object), in which case the named file is opened, or it can
be an existing file object to read from or write to.
mode can be "r" for reading (default), "w" for (over)writing,
"x" for creating exclusively, or "a" for appending. These can
equivalently be given as "rb", "wb", "xb" and "ab" respectively.
format specifies the container format to use for the file.
If mode is "r", this defaults to FORMAT_AUTO. Otherwise, the
default is FORMAT_XZ.
check specifies the integrity check to use. This argument can
only be used when opening a file for writing. For FORMAT_XZ,
the default is CHECK_CRC64. FORMAT_ALONE and FORMAT_RAW do not
support integrity checks - for these formats, check must be
omitted, or be CHECK_NONE.
When opening a file for reading, the *preset* argument is not
meaningful, and should be omitted. The *filters* argument should
also be omitted, except when format is FORMAT_RAW (in which case
it is required).
When opening a file for writing, the settings used by the
compressor can be specified either as a preset compression
level (with the *preset* argument), or in detail as a custom
filter chain (with the *filters* argument). For FORMAT_XZ and
FORMAT_ALONE, the default is to use the PRESET_DEFAULT preset
level. For FORMAT_RAW, the caller must always specify a filter
chain; the raw compressor does not support preset compression
levels.
preset (if provided) should be an integer in the range 0-9,
optionally OR-ed with the constant PRESET_EXTREME.
filters (if provided) should be a sequence of dicts. Each dict
should have an entry for "id" indicating ID of the filter, plus
additional entries for options to the filter.
"""
self._fp = None
self._closefp = False
self._mode = _MODE_CLOSED
if mode in ("r", "rb"):
if check != -1:
raise ValueError("Cannot specify an integrity check "
"when opening a file for reading")
if preset is not None:
raise ValueError("Cannot specify a preset compression "
"level when opening a file for reading")
if format is None:
format = FORMAT_AUTO
mode_code = _MODE_READ
elif mode in ("w", "wb", "a", "ab", "x", "xb"):
if format is None:
format = FORMAT_XZ
mode_code = _MODE_WRITE
self._compressor = LZMACompressor(format=format, check=check,
preset=preset, filters=filters)
self._pos = 0
else:
raise ValueError("Invalid mode: {!r}".format(mode))
if isinstance(filename, (str, bytes)):
if "b" not in mode:
mode += "b"
self._fp = builtins.open(filename, mode)
self._closefp = True
self._mode = mode_code
elif hasattr(filename, "read") or hasattr(filename, "write"):
self._fp = filename
self._mode = mode_code
else:
raise TypeError("filename must be a str or bytes object, or a file")
if self._mode == _MODE_READ:
raw = _compression.DecompressReader(self._fp, LZMADecompressor,
trailing_error=LZMAError, format=format, filters=filters)
self._buffer = io.BufferedReader(raw)
def close(self):
"""Flush and close the file.
May be called more than once without error. Once the file is
closed, any other operation on it will raise a ValueError.
"""
if self._mode == _MODE_CLOSED:
return
try:
if self._mode == _MODE_READ:
self._buffer.close()
self._buffer = None
elif self._mode == _MODE_WRITE:
self._fp.write(self._compressor.flush())
self._compressor = None
finally:
try:
if self._closefp:
self._fp.close()
finally:
self._fp = None
self._closefp = False
self._mode = _MODE_CLOSED
@property
def closed(self):
"""True if this file is closed."""
return self._mode == _MODE_CLOSED
def fileno(self):
"""Return the file descriptor for the underlying file."""
self._check_not_closed()
return self._fp.fileno()
def seekable(self):
"""Return whether the file supports seeking."""
return self.readable() and self._buffer.seekable()
def readable(self):
"""Return whether the file was opened for reading."""
self._check_not_closed()
return self._mode == _MODE_READ
def writable(self):
"""Return whether the file was opened for writing."""
self._check_not_closed()
return self._mode == _MODE_WRITE
def peek(self, size=-1):
"""Return buffered data without advancing the file position.
Always returns at least one byte of data, unless at EOF.
The exact number of bytes returned is unspecified.
"""
self._check_can_read()
# Relies on the undocumented fact that BufferedReader.peek() always
# returns at least one byte (except at EOF)
return self._buffer.peek(size)
def read(self, size=-1):
"""Read up to size uncompressed bytes from the file.
If size is negative or omitted, read until EOF is reached.
Returns b"" if the file is already at EOF.
"""
self._check_can_read()
return self._buffer.read(size)
def read1(self, size=-1):
"""Read up to size uncompressed bytes, while trying to avoid
making multiple reads from the underlying stream. Reads up to a
buffer's worth of data if size is negative.
Returns b"" if the file is at EOF.
"""
self._check_can_read()
if size < 0:
size = io.DEFAULT_BUFFER_SIZE
return self._buffer.read1(size)
def readline(self, size=-1):
"""Read a line of uncompressed bytes from the file.
The terminating newline (if present) is retained. If size is
non-negative, no more than size bytes will be read (in which
case the line may be incomplete). Returns b'' if already at EOF.
"""
self._check_can_read()
return self._buffer.readline(size)
def write(self, data):
"""Write a bytes object to the file.
Returns the number of uncompressed bytes written, which is
always len(data). Note that due to buffering, the file on disk
may not reflect the data written until close() is called.
"""
self._check_can_write()
compressed = self._compressor.compress(data)
self._fp.write(compressed)
self._pos += len(data)
return len(data)
def seek(self, offset, whence=io.SEEK_SET):
"""Change the file position.
The new position is specified by offset, relative to the
position indicated by whence. Possible values for whence are:
0: start of stream (default): offset must not be negative
1: current stream position
2: end of stream; offset must not be positive
Returns the new file position.
Note that seeking is emulated, so depending on the parameters,
this operation may be extremely slow.
"""
self._check_can_seek()
return self._buffer.seek(offset, whence)
def tell(self):
"""Return the current file position."""
self._check_not_closed()
if self._mode == _MODE_READ:
return self._buffer.tell()
return self._pos
def open(filename, mode="rb", *,
format=None, check=-1, preset=None, filters=None,
encoding=None, errors=None, newline=None):
"""Open an LZMA-compressed file in binary or text mode.
filename can be either an actual file name (given as a str or bytes
object), in which case the named file is opened, or it can be an
existing file object to read from or write to.
The mode argument can be "r", "rb" (default), "w", "wb", "x", "xb",
"a", or "ab" for binary mode, or "rt", "wt", "xt", or "at" for text
mode.
The format, check, preset and filters arguments specify the
compression settings, as for LZMACompressor, LZMADecompressor and
LZMAFile.
For binary mode, this function is equivalent to the LZMAFile
constructor: LZMAFile(filename, mode, ...). In this case, the
encoding, errors and newline arguments must not be provided.
For text mode, an LZMAFile object is created, and wrapped in an
io.TextIOWrapper instance with the specified encoding, error
handling behavior, and line ending(s).
"""
if "t" in mode:
if "b" in mode:
raise ValueError("Invalid mode: %r" % (mode,))
else:
if encoding is not None:
raise ValueError("Argument 'encoding' not supported in binary mode")
if errors is not None:
raise ValueError("Argument 'errors' not supported in binary mode")
if newline is not None:
raise ValueError("Argument 'newline' not supported in binary mode")
lz_mode = mode.replace("t", "")
binary_file = LZMAFile(filename, lz_mode, format=format, check=check,
preset=preset, filters=filters)
if "t" in mode:
return io.TextIOWrapper(binary_file, encoding, errors, newline)
else:
return binary_file
def compress(data, format=FORMAT_XZ, check=-1, preset=None, filters=None):
"""Compress a block of data.
Refer to LZMACompressor's docstring for a description of the
optional arguments *format*, *check*, *preset* and *filters*.
For incremental compression, use an LZMACompressor instead.
"""
comp = LZMACompressor(format, check, preset, filters)
return comp.compress(data) + comp.flush()
def decompress(data, format=FORMAT_AUTO, memlimit=None, filters=None):
"""Decompress a block of data.
Refer to LZMADecompressor's docstring for a description of the
optional arguments *format*, *check* and *filters*.
For incremental decompression, use an LZMADecompressor instead.
"""
results = []
while True:
decomp = LZMADecompressor(format, memlimit, filters)
try:
res = decomp.decompress(data)
except LZMAError:
if results:
break # Leftover data is not a valid LZMA/XZ stream; ignore it.
else:
raise # Error on the first iteration; bail out.
results.append(res)
if not decomp.eof:
raise LZMAError("Compressed data ended before the "
"end-of-stream marker was reached")
data = decomp.unused_data
if not data:
break
return b"".join(results)
|
py | 7dff1c8feb3752c6fed51f68a340d8d3d4708b67 | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
import time
import unittest
import os
import shutil
from ai_flow import AIFlowServerRunner, init_ai_flow_context
from ai_flow.workflow.status import Status
from ai_flow_plugins.job_plugins import bash
from ai_flow.test.util.notification_service_utils import start_notification_server, stop_notification_server
import ai_flow as af
project_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
class TestBash(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
cls.ns_server = start_notification_server()
config_file = project_path + '/master.yaml'
cls.master = AIFlowServerRunner(config_file=config_file)
cls.master.start()
@classmethod
def tearDownClass(cls) -> None:
cls.master.stop()
generated = '{}/generated'.format(project_path)
if os.path.exists(generated):
shutil.rmtree(generated)
temp = '{}/temp'.format(project_path)
if os.path.exists(temp):
shutil.rmtree(temp)
stop_notification_server(cls.ns_server)
def setUp(self):
self.master._clear_db()
af.current_graph().clear_graph()
init_ai_flow_context()
def tearDown(self):
self.master._clear_db()
def test_bash_task(self):
with af.job_config('task_1'):
af.user_define_operation(processor=bash.BashProcessor(bash_command='echo "Xiao ming hello world!"'))
w = af.workflow_operation.submit_workflow(workflow_name='test_bash')
je = af.workflow_operation.start_job_execution(job_name='task_1', execution_id='1')
jes = af.workflow_operation.get_job_executions(job_name='task_1', execution_id='1')
self.assertEqual(Status.FINISHED, jes[0].status)
def test_stop_bash_task(self):
time.sleep(1)
with af.job_config('task_1'):
af.user_define_operation(processor=bash.BashProcessor(bash_command='sleep 10'))
w = af.workflow_operation.submit_workflow(workflow_name='test_bash')
je = af.workflow_operation.start_job_execution(job_name='task_1', execution_id='1')
af.workflow_operation.stop_job_execution(job_name='task_1', execution_id='1')
jes = af.workflow_operation.get_job_executions(job_name='task_1', execution_id='1')
self.assertEqual(Status.FAILED, jes[0].status)
self.assertTrue('err' in jes[0].properties)
if __name__ == '__main__':
unittest.main()
|
py | 7dff1ceef61f17990dfb2d4b2e0801f801bc4020 | #! python3
# -*- coding: utf-8 -*-
import time
import binascii
test_str = b'Hello World.'
'''hashlib'''
import hashlib
per_st = time.perf_counter()
m = hashlib.sha256(test_str).digest()
per_ed = time.perf_counter()
print(binascii.hexlify(m))
print('run time use hashlib: ' + str(per_ed - per_st) + ' s')
'''pycryptodome'''
from Crypto.Hash import SHA256
per_st = time.perf_counter()
h = SHA256.new(test_str).digest()
per_ed = time.perf_counter()
print(binascii.hexlify(h))
print('run time use pycryptodome: ' + str(per_ed - per_st) + ' s')
'''cryptography'''
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
per_st = time.perf_counter()
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(test_str)
s = digest.finalize()
per_ed = time.perf_counter()
print(binascii.hexlify(s))
print('run time use cryptography: ' + str(per_ed - per_st) + ' s')
|
py | 7dff1d031606574d17b990f88dd82d9aaa0259ba | # coding=utf-8
# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# 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.
""" Finetuning the library models for sequence classification on GLUE (Bert, XLM, XLNet, RoBERTa, Albert, XLM-RoBERTa)."""
import dataclasses
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Callable, Dict, Optional
import numpy as np
from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer, EvalPrediction, GlueDataset
from transformers import GlueDataTrainingArguments as DataTrainingArguments
from transformers import (
HfArgumentParser,
Trainer,
TrainingArguments,
glue_compute_metrics,
glue_output_modes,
glue_tasks_num_labels,
set_seed,
)
# 指定训练模型的GPU是哪一个，但是仍然有问题，如果我想在n个GPU上并行训练，该怎么做？
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
logger = logging.getLogger(__name__)
@dataclass
class ModelArguments:
"""
Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
"""
model_name_or_path: str = field(
metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
)
config_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
)
tokenizer_name: Optional[str] = field(
default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
)
cache_dir: Optional[str] = field(
default=None, metadata={"help": "Where do you want to store the pretrained models downloaded from s3"}
)
def main():
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
# step1. 解析参数
parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
# step2.判断输出文件是否已经存在
# 为什么要判断一下？ 难道是想我们继续从之前的模型开始输入？ 那么这里就可以有一个优化，如果是
# 模型已经有过输出了，那么就从这个输出开始继续训练
if (
os.path.exists(training_args.output_dir)
and os.listdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
)
# step3. 配置日志信息
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,
)
logger.warning(
"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
training_args.local_rank,
training_args.device,
training_args.n_gpu,
bool(training_args.local_rank != -1),
training_args.fp16,
)
logger.info("Training/evaluation parameters %s", training_args)
# step 4. 设置随机种子 ？ =》 有什么用？
# Set seed
set_seed(training_args.seed)
# step 5.下面这个操作是什么意思？
try:
num_labels = glue_tasks_num_labels[data_args.task_name]
output_mode = glue_output_modes[data_args.task_name]
except KeyError:
raise ValueError("Task not found: %s" % (data_args.task_name))
# step 6. Load pretrained model and tokenizer
#
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
# download model & vocab.
config = AutoConfig.from_pretrained(
model_args.config_name if model_args.config_name else model_args.model_name_or_path,
num_labels=num_labels,
finetuning_task=data_args.task_name,
cache_dir=model_args.cache_dir,
)
tokenizer = AutoTokenizer.from_pretrained(
model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
cache_dir=model_args.cache_dir,
)
model = AutoModelForSequenceClassification.from_pretrained(
model_args.model_name_or_path,
from_tf=bool(".ckpt" in model_args.model_name_or_path),
config=config,
cache_dir=model_args.cache_dir,
)
# step7. Get datasets
# 分别为train, eval, test 设置数据集
train_dataset = (
GlueDataset(data_args,
tokenizer=tokenizer,
cache_dir=model_args.cache_dir) if training_args.do_train else None
)
eval_dataset = (
GlueDataset(data_args,
tokenizer=tokenizer,
mode="dev",
cache_dir=model_args.cache_dir)
if training_args.do_eval
else None
)
test_dataset = (
GlueDataset(data_args,
tokenizer=tokenizer,
mode="test",
cache_dir=model_args.cache_dir)
if training_args.do_predict
else None
)
# step 8. 定义评价时的metric
# 这里进行了多层的函数嵌套 => 以task_name = mrpc 为例
def build_compute_metrics_fn(task_name: str) -> Callable[[EvalPrediction], Dict]:
def compute_metrics_fn(p: EvalPrediction):
if output_mode == "classification":
preds = np.argmax(p.predictions, axis=1)
elif output_mode == "regression":
preds = np.squeeze(p.predictions)
return glue_compute_metrics(task_name, preds, p.label_ids)
return compute_metrics_fn # 返回的是个函数
# step 9.Initialize our Trainer
""" 分别来谈一下其中参数的作用
01.compute_metrics (Callable[[EvalPrediction], Dict], optional):
The function that will be used to compute metrics at evaluation.
Must take a EvalPrediction and return a dictionary string to metric values.
02. 通常的情况是，程序运行到这一步，如果GPU的内存不足，就会报 CUDA error: out of memory
"""
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
compute_metrics=build_compute_metrics_fn(data_args.task_name),
)
# step 10.Training
if training_args.do_train:
trainer.train( # 开始真正训练的入口
model_path=model_args.model_name_or_path
if os.path.isdir(model_args.model_name_or_path) else None
)
trainer.save_model()
# For convenience, we also re-save the tokenizer to the same directory,
# so that you can share your model easily on huggingface.co/models =)
if trainer.is_world_master():
tokenizer.save_pretrained(training_args.output_dir)
# step 11.Evaluation
eval_results = {}
if training_args.do_eval:
logger.info("*** Evaluate ***")
# Loop to handle MNLI double evaluation (matched, mis-matched)
eval_datasets = [eval_dataset]
if data_args.task_name == "mnli":
mnli_mm_data_args = dataclasses.replace(data_args, task_name="mnli-mm")
eval_datasets.append(
GlueDataset(mnli_mm_data_args, tokenizer=tokenizer, mode="dev", cache_dir=model_args.cache_dir)
)
for eval_dataset in eval_datasets:
trainer.compute_metrics = build_compute_metrics_fn(eval_dataset.args.task_name)
eval_result = trainer.evaluate(eval_dataset=eval_dataset)
output_eval_file = os.path.join(
training_args.output_dir, f"eval_results_{eval_dataset.args.task_name}.txt"
)
if trainer.is_world_master():
with open(output_eval_file, "w") as writer:
logger.info("***** Eval results {} *****".format(eval_dataset.args.task_name))
for key, value in eval_result.items():
logger.info(" %s = %s", key, value) # 打日志的同时写入到文件中
writer.write("%s = %s\n" % (key, value))
eval_results.update(eval_result)
if training_args.do_predict:
logging.info("*** Test ***")
test_datasets = [test_dataset]
if data_args.task_name == "mnli":
mnli_mm_data_args = dataclasses.replace(data_args, task_name="mnli-mm")
test_datasets.append(
GlueDataset(mnli_mm_data_args, tokenizer=tokenizer, mode="test", cache_dir=model_args.cache_dir)
)
for test_dataset in test_datasets:
predictions = trainer.predict(test_dataset=test_dataset).predictions
if output_mode == "classification":
predictions = np.argmax(predictions, axis=1)
output_test_file = os.path.join(
training_args.output_dir, f"test_results_{test_dataset.args.task_name}.txt"
)
if trainer.is_world_master():
with open(output_test_file, "w") as writer:
logger.info("***** Test results {} *****".format(test_dataset.args.task_name))
writer.write("index\tprediction\n")
for index, item in enumerate(predictions):
if output_mode == "regression":
writer.write("%d\t%3.3f\n" % (index, item))
else:
item = test_dataset.get_labels()[item]
writer.write("%d\t%s\n" % (index, item))
return eval_results
def _mp_fn(index):
# For xla_spawn (TPUs)
main()
if __name__ == "__main__":
main() |
py | 7dff1f6af0486b029bacaf13cc86f9853e044739 | import tempfile
import sacc
import sacc.data_types
import numpy as np
import pytest
import os
import pathlib
import urllib
import time
test_dir = pathlib.Path(__file__).resolve().parent
test_data_dir = test_dir / 'data'
# idea based on TreeCorr tests
def get_from_wiki(url):
file_name = url.split('/')[-1]
local_file_name = test_data_dir / file_name
if not local_file_name.exists():
print(f"Downlading {url} to data dir")
try:
urllib.request.urlretrieve(url, local_file_name)
except urllib.request.HTTPError as err:
if err.code == 429:
print("Rate limit download - waiting 10 seconds to try again")
time.sleep(10)
urllib.request.urlretrieve(url, local_file_name)
else:
raise
return local_file_name
def test_quantity_warning():
s = sacc.Sacc()
with pytest.warns(UserWarning):
s.add_tracer('Misc', 'source_0',
quantity='dummy')
def test_data_type_warning():
s = sacc.Sacc()
s.add_tracer('Misc', 'source_0')
with pytest.warns(UserWarning):
s.add_data_point('cl_wrong', ('source_0', 'source_0'),
0.1, ell=10.)
def test_construct():
s = sacc.Sacc()
# Tracer
z = np.arange(0., 1.0, 0.01)
nz = (z-0.5)**2/0.1**2
s.add_tracer('NZ', 'source_0', z, nz,
quantity='galaxy_density')
for i in range(20):
ee = 0.1 * i
tracers = ('source_0', 'source_0')
s.add_data_point(sacc.standard_types.cl_00, tracers, ee, ell=10.0*i)
def test_tracers_later():
s = sacc.Sacc()
with pytest.raises(ValueError):
tracers = ('source_0', 'source_0')
s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, 0.0, ell=1)
s = sacc.Sacc()
tracers = ('source_0', 'source_0')
s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, 0.0, tracers_later=True, ell=1)
def test_full_cov():
covmat = np.random.uniform(size=(100, 100))
C = sacc.covariance.BaseCovariance.make(covmat)
assert C.size == 100
assert isinstance(C, sacc.covariance.FullCovariance)
assert np.all(C.covmat == covmat)
hdu = C.to_hdu()
C2 = sacc.covariance.BaseCovariance.from_hdu(hdu)
assert np.allclose(C.covmat, C2.covmat)
def test_block_cov():
covmat = [np.random.uniform(size=(50, 50)),
np.random.uniform(size=(100, 100)),
np.random.uniform(size=(150, 150))]
C = sacc.covariance.BaseCovariance.make(covmat)
assert C.size == 300
assert isinstance(C, sacc.covariance.BlockDiagonalCovariance)
hdu = C.to_hdu()
C2 = sacc.covariance.BaseCovariance.from_hdu(hdu)
assert len(C2.blocks) == 3
assert C.block_sizes == C2.block_sizes
for i in range(3):
assert np.allclose(C.blocks[i], C2.blocks[i])
def test_misc_tracer():
md1 = {'potato': 'if_necessary', 'answer': 42, 'height': 1.83}
md2 = {'potato': 'never'}
T1 = sacc.BaseTracer.make('Misc', 'tracer1',
quantity='generic', metadata=md1)
T2 = sacc.BaseTracer.make('Misc', 'tracer2',
quantity='generic', metadata=md2)
assert T1.metadata == md1
assert T2.metadata == md2
tables = sacc.BaseTracer.to_tables([T1, T2])
D = sacc.BaseTracer.from_tables(tables)
T1a = D['tracer1']
T2a = D['tracer2']
assert T1a.metadata == md1
assert T2a.metadata == md2
def test_numap_tracer():
md1 = {'mac': 'yes', 'cheese': 'of_course', 'quantity': 3}
md2 = {'mac': 'no', 'cheese': 'no'}
ell = np.linspace(2, 1000, 1000)
beam = np.exp(-0.1 * ell * (ell + 1))
beam_extra = {'err1': np.sin(ell * 0.1)}
nu = np.linspace(30., 60., 100)
bandpass = np.ones(100)
bandpass_extra = {'err1': bandpass * 0.1,
'err2': bandpass * 0.05}
T1 = sacc.BaseTracer.make('NuMap', 'band1', 0,
nu, bandpass, ell, beam,
quantity='cmb_temperature',
bandpass_extra=bandpass_extra,
beam_extra=beam_extra,
metadata=md2)
T2 = sacc.BaseTracer.make('NuMap', 'band2', 0,
nu, bandpass, ell, beam,
quantity='cmb_convergence',
bandpass_extra=bandpass_extra,
beam_extra=beam_extra,
metadata=md1)
assert T2.metadata == md1
assert T1.metadata == md2
tables = sacc.BaseTracer.to_tables([T1, T2])
D = sacc.BaseTracer.from_tables(tables)
T1a = D['band1']
T2a = D['band2']
assert T1a.metadata == md2
assert T2a.metadata == md1
assert np.all(T1a.bandpass_extra['err1'] == 0.1 * bandpass)
def test_map_tracer():
md1 = {'mac': 'yes', 'cheese': 'of_course', 'quantity': 3}
md2 = {'mac': 'no', 'cheese': 'no'}
ell = np.linspace(2, 1000, 1000)
beam = np.exp(-0.1 * ell * (ell + 1))
err = np.sin(ell * 0.1)
beam_extra = {'err1': err}
T1 = sacc.BaseTracer.make('Map', 'y_milca',
0, ell, beam,
quantity='cmb_tSZ',
beam_extra=beam_extra,
metadata=md1)
T2 = sacc.BaseTracer.make('Map', 'y_nilc',
0, ell, beam,
quantity='cmb_kSZ',
beam_extra=beam_extra,
metadata=md2)
assert T1.metadata == md1
assert T2.metadata == md2
tables = sacc.BaseTracer.to_tables([T1, T2])
D = sacc.BaseTracer.from_tables(tables)
T1a = D['y_milca']
T2a = D['y_nilc']
assert T1a.metadata == md1
assert T2a.metadata == md2
assert np.all(T1a.beam_extra['err1'] == err)
def test_nz_tracer():
md1 = {'potato': 'if_necessary', 'answer': 42, 'height': 1.83}
md2 = {'potato': 'never'}
z = np.arange(0., 1., 0.01)
Nz1 = 1*z # not a sensible N(z)!
Nz2 = 2*z # not a sensible N(z)!
Nz3 = 3*z
Nz4 = 4*z
more_nz = {'v1': Nz3, 'v2': Nz4}
T1 = sacc.BaseTracer.make('NZ', 'tracer1', z, Nz1,
quantity='galaxy_density',
extra_columns=more_nz,
spin=0,
metadata=md1)
T2 = sacc.BaseTracer.make('NZ', 'tracer2', z, Nz2,
quantity='galaxy_shear',
spin=2,
metadata=md2)
assert T1.metadata == md1
assert T2.metadata == md2
tables = sacc.BaseTracer.to_tables([T1, T2])
D = sacc.BaseTracer.from_tables(tables)
T1a = D['tracer1']
T2a = D['tracer2']
assert T1a.metadata == md1
assert T2a.metadata == md2
assert np.all(T1a.extra_columns['v1'] == Nz3)
assert np.all(T1a.extra_columns['v2'] == Nz4)
def test_mixed_tracers():
md1 = {'potato': 'never'}
md2 = {'rank': 'duke'}
md3 = {'rank': 'earl', 'robes': 78}
z = np.arange(0., 1., 0.01)
Nz1 = 1*z # not a sensible N(z)!
Nz2 = 2*z
T1 = sacc.BaseTracer.make('NZ', 'tracer1', z, Nz1,
quantity='galaxy_convergence')
T2 = sacc.BaseTracer.make('NZ', 'tracer2', z, Nz2,
quantity='galaxy_shear', metadata=md1)
M1 = sacc.BaseTracer.make("Misc", "sample1", metadata=md2)
M2 = sacc.BaseTracer.make("Misc", "sample2", metadata=md3)
tables = sacc.BaseTracer.to_tables([T1, M1, T2, M2])
recovered = sacc.BaseTracer.from_tables(tables)
assert recovered['sample1'].metadata['rank'] == 'duke'
assert recovered['sample2'].metadata['robes'] == 78
assert np.all(recovered['tracer1'].nz == Nz1)
assert recovered['tracer2'].metadata['potato'] == 'never'
def test_inverses():
N = 25
C = np.random.uniform(0, 1, size=(N, N))
C = (C+C.T) + np.eye(N)*20
M1 = sacc.BaseCovariance.make(C)
assert M1.size == N
invC = M1.inverse
ii = np.dot(invC, C)
assert np.allclose(ii, np.eye(N))
blocks = [np.random.uniform(0, 1, size=(5, 5))
for i in range(5)]
for b in blocks:
b += b.T + np.eye(5)*20
M2 = sacc.BaseCovariance.make(blocks)
assert M2.size == N
M2dense = np.zeros((N, N))
for i in range(5):
M2dense[i*5:i*5+5, i*5:i*5+5] = blocks[i]
invC2 = M2.inverse
ii = np.dot(invC2, M2dense)
assert np.allclose(ii, np.eye(N))
d = abs(np.random.uniform(0, 1, size=N))+1
M3 = sacc.BaseCovariance.make(d)
assert M3.size == N
invC3 = M3.inverse
assert np.count_nonzero(invC3 - np.diag(np.diagonal(invC3))) == 0
assert np.allclose(invC3.diagonal() * d, 1)
def test_data_point():
from sacc.data_types import DataPoint
dt = sacc.data_types.standard_types.galaxy_shearDensity_cl_e
value = 13.4
tracers = ('aaa', 'bbb')
tags = {'ell': 12, 'theta': 14.3}
d = DataPoint(dt, tracers, value, **tags)
s = repr(d)
d2 = eval(s)
assert d.tracers == d2.tracers
assert d.tags == d2.tags
assert d.data_type == d2.data_type
assert d.value == d2.value
def test_keep_remove():
s = sacc.Sacc()
# Tracer
z = np.arange(0., 1.0, 0.01)
nz = (z-0.5)**2/0.1**2
s.add_tracer('NZ', 'source_0', z, nz)
s.add_tracer('NZ', 'source_1', z, nz,
quantity='galaxy_shear', spin=2)
s.add_tracer('NZ', 'source_2', z, nz,
quantity='cluster_density')
for i in range(20):
ee = 0.1 * i
tracers = ('source_0', 'source_0')
s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, ee, ell=10.0*i)
for i in range(20):
bb = 0.1 * i
tracers = ('source_1', 'source_1')
s.add_data_point(sacc.standard_types.galaxy_shear_cl_bb,
tracers, bb, ell=10.0*i)
for i in range(20):
ee = 0.1 * i
tracers = ('source_2', 'source_2')
s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, ee, ell=10.0*i)
# Select by data type
s2 = s.copy()
s2.keep_selection(data_type=sacc.standard_types.galaxy_shear_cl_bb)
assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_bb
for d in s2.data)
assert len(s2) == 20
# From multiple tracers
s2 = s.copy()
s2.keep_selection(data_type=sacc.standard_types.galaxy_shear_cl_ee)
assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_ee
for d in s2.data)
assert len(s2) == 40
# Test removing a single tracer
s2 = s.copy()
s2.remove_selection(tracers=('source_1', 'source_1'))
for i, d in enumerate(s2.data):
if i < 20:
assert d.tracers == ('source_0', 'source_0')
else:
assert d.tracers == ('source_2', 'source_2')
assert all(d.data_type == sacc.standard_types.galaxy_shear_cl_ee
for d in s2.data)
assert len(s2) == 40
# Test selecting by tag
s2 = s.copy()
s2.remove_selection(ell__lt=55)
ell = s2.get_tag('ell')
for e in ell:
assert e > 55
s2 = s.copy()
s2.keep_selection(ell__lt=55)
ell = s2.get_tag('ell')
for e in ell:
assert e < 55
# Cutting just by index
s2 = s.copy()
ind = s2.indices(tracers=('source_1', 'source_1'))
assert (ind == np.arange(20, 40)).all()
# multiple selections
s2 = s.copy()
ind = s2.indices(tracers=('source_2', 'source_2'), ell__lt=45)
assert len(ind) == 5
def test_cutting_block_cov():
covmat = [np.random.uniform(size=(50, 50)),
np.random.uniform(size=(100, 100)),
np.random.uniform(size=(150, 150))]
C = sacc.covariance.BaseCovariance.make(covmat)
ind = list(range(50))
C2 = C.keeping_indices(np.arange(50))
assert C2.size == len(ind)
assert np.allclose(C2.get_block(ind), covmat[0])
def test_cutting_block_cov2():
covmat = [np.random.uniform(size=(50, 50)),
np.random.uniform(size=(100, 100)),
np.random.uniform(size=(150, 150))]
C = sacc.covariance.BaseCovariance.make(covmat)
ind = list(range(50,150))
C2 = C.keeping_indices(np.arange(50,150))
assert C2.size == len(ind)
assert np.allclose(C2.get_block(range(100)), covmat[1])
def test_cutting_full_cov():
covmat = np.random.uniform(size=(100, 100))
C = sacc.covariance.BaseCovariance.make(covmat)
ind = np.arange(10, dtype=int)
C2 = C.keeping_indices(ind)
assert np.allclose(C2.get_block(ind),
covmat[:10, :10])
def test_cutting_diag_cov():
diag = np.random.uniform(size=(100,))
C = sacc.covariance.BaseCovariance.make(diag)
ind = np.arange(20, dtype=int)
C2 = C.keeping_indices(ind)
assert np.allclose(C2.get_block(ind).diagonal(), diag[:20])
def test_parse_data_names():
for name in sacc.data_types.required_tags_verbose:
sources, props, stat, sub = sacc.parse_data_type_name(name)
name2 = sacc.build_data_type_name(sources, props, stat, sub)
assert name == name2
def test_bandpower_window():
nb = 20
nl = 200
dl = nl // nb
ells = np.arange(nl)
w = np.zeros([nb, nl])
for i in range(nb):
w[i, i*dl: (i+1)*dl] = 1./dl
W1 = [sacc.BandpowerWindow(ells, w.T)]
tables = sacc.BandpowerWindow.to_tables(W1)
W2 = sacc.BandpowerWindow.from_tables(tables)
for w1 in W1:
w2 = W2[id(w1)]
assert np.all(w1.values == w2.values)
assert np.all(w1.weight.flatten() == w2.weight.flatten())
def test_tophat_window():
edges = np.arange(10) * 10
W1 = [sacc.TopHatWindow(edges[:-1], edges[1:])]
tables = sacc.TopHatWindow.to_tables(W1)
W2 = sacc.TopHatWindow.from_tables(tables)
for w1 in W1:
w2 = W2[id(w1)]
assert np.all(w1.min == w2.min)
assert np.all(w1.max == w2.max)
def test_log_window():
edges = (np.arange(10) + 1) * 10
W1 = [sacc.LogTopHatWindow(edges[:-1], edges[1:])]
tables = sacc.LogTopHatWindow.to_tables(W1)
W2 = sacc.LogTopHatWindow.from_tables(tables)
for w1 in W1:
w2 = W2[id(w1)]
assert np.all(w1.min == w2.min)
assert np.all(w1.max == w2.max)
def test_concatenate_covariance():
v1 = np.array([1., 2., 3.])
v2 = np.array([4.])
A = sacc.BaseCovariance.make(v1)
B = sacc.BaseCovariance.make(v2)
C = sacc.covariance.concatenate_covariances(A, B)
assert isinstance(C, sacc.covariance.DiagonalCovariance)
assert np.allclose(C.diag, [1, 2, 3, 4])
v1 = np.array([2.])
v2 = np.array([[3., 0.1], [0.1, 3]])
A = sacc.BaseCovariance.make(v1)
B = sacc.BaseCovariance.make(v2)
C = sacc.covariance.concatenate_covariances(A, B)
assert isinstance(C, sacc.covariance.BlockDiagonalCovariance)
test_C = np.array([
[2.0, 0.0, 0.0],
[0.0, 3.0, 0.1],
[0.0, 0.1, 3.0]]
)
assert np.allclose(C.dense, test_C)
v1 = np.array([[2.0, 0.2, ],
[0.2, 3.0, ]])
v2 = np.array([[4.0, -0.2, ],
[-0.2, 5.0, ]])
test_C = np.array([[2.0, 0.2, 0.0, 0.0],
[0.2, 3.0, 0.0, 0.0],
[0.0, 0.0, 4.0, -0.2],
[0.0, 0.0, -0.2, 5.0]])
A = sacc.BaseCovariance.make(v1)
B = sacc.BaseCovariance.make(v2)
C = sacc.covariance.concatenate_covariances(A, B)
assert isinstance(C, sacc.covariance.BlockDiagonalCovariance)
assert np.allclose(C.dense, test_C)
def test_concatenate_data():
s1 = sacc.Sacc()
# Tracer
z = np.arange(0., 1.0, 0.01)
nz = (z-0.5)**2/0.1**2
s1.add_tracer('NZ', 'source_0', z, nz)
for i in range(20):
ee = 0.1 * i
tracers = ('source_0', 'source_0')
s1.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, ee, ell=10.0*i)
s2 = sacc.Sacc()
# Tracer
z = np.arange(0., 1.0, 0.01)
nz = (z-0.5)**2/0.1**2
s2.add_tracer('NZ', 'source_0', z, nz,
quantity='galaxy_shear', spin=2)
for i in range(20):
ee = 0.1 * i
tracers = ('source_0', 'source_0')
s2.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, ee, ell=10.0*i, label='xxx')
# same tracer
s3 = sacc.concatenate_data_sets(s1, s2, same_tracers=['source_0'])
assert ['source_0'] == list(s3.tracers.keys())
# check data points in right order
for i in range(20):
assert s3.data[i].get_tag('ell') == 10.0*i
assert s3.data[i+20].get_tag('ell') == 10.0*i
assert s3.data[i].get_tag('label') is None
assert s3.data[i+20].get_tag('label') == 'xxx'
t1 = s3.data[i].tracers[0]
t2 = s3.data[i+20].tracers[0]
assert t1 == 'source_0'
assert t1 == t2
# To make sure the first 'source_0' tracer is used and not rewritten
s3.get_tracer(t1).quantity == 'generic'
# name clash
with pytest.raises(ValueError):
sacc.concatenate_data_sets(s1, s2)
s3 = sacc.concatenate_data_sets(s1, s2, labels=['1', '2'])
assert 'source_0_1' in s3.tracers
assert 'source_0_2' in s3.tracers
assert len(s3) == len(s1) + len(s2)
# check data points in right order
for i in range(20):
assert s3.data[i].get_tag('ell') == 10.0*i
assert s3.data[i+20].get_tag('ell') == 10.0*i
assert s3.data[i].get_tag('label') == '1'
assert s3.data[i+20].get_tag('label') == 'xxx_2'
t1 = s3.data[i].tracers[0]
t2 = s3.data[i+20].tracers[0]
assert t1 == 'source_0_1'
assert t2 == 'source_0_2'
s3.get_tracer(t1)
s3.get_tracer(t2)
# labels + same_tracers
s4 = sacc.concatenate_data_sets(s3, s3, labels=['x', 'y'],
same_tracers=['source_0_1'])
trs = ['source_0_1', 'source_0_2_x', 'source_0_2_y']
assert trs == list(s4.tracers.keys())
assert s4.mean.size == 2 * s3.mean.size
def test_io():
s = sacc.Sacc()
# Tracer
z = np.arange(0., 1.0, 0.01)
nz = (z-0.5)**2/0.1**2
s.add_tracer('NZ', 'source_0', z, nz)
for i in range(20):
ee = 0.1 * i
tracers = ('source_0', 'source_0')
s.add_data_point(sacc.standard_types.galaxy_shear_cl_ee,
tracers, ee, ell=10.0*i)
with tempfile.TemporaryDirectory() as tmpdir:
filename = os.path.join(tmpdir, 'test.sacc')
s.save_fits(filename)
s2 = sacc.Sacc.load_fits(filename)
assert len(s2) == 20
mu = s2.get_mean(sacc.standard_types.galaxy_shear_cl_ee)
for i in range(20):
assert mu[i] == 0.1 * i
def test_io_maps_bpws():
s = sacc.Sacc()
n_ell = 10
d_ell = 100
n_ell_large = n_ell * d_ell
ell = np.linspace(2, 1000, n_ell)
c_ell = 1./(ell+1)**3
beam = np.exp(-0.1 * ell * (ell+1))
nu = np.linspace(30., 60., 100)
bandpass = np.ones(100)
z = np.arange(0., 1.0, 0.01)
nz = (z-0.5)**2/0.1**2
# Tracer
s.add_tracer('NZ', 'gc', z, nz)
s.add_tracer('NuMap', 'cmbp', 2, nu, bandpass, ell, beam)
s.add_tracer('Map', 'sz', 0, ell, beam)
# Window
ells_large = np.arange(n_ell_large)
window_single = np.zeros([n_ell, n_ell_large])
for i in range(n_ell):
window_single[i, i * d_ell: (i + 1) * d_ell] = 1.
wins = sacc.BandpowerWindow(ells_large, window_single.T)
s.add_ell_cl('cl_00', 'gc', 'gc', ell, c_ell, window=wins)
s.add_ell_cl('cl_0e', 'gc', 'cmbp', ell, c_ell, window=wins)
s.add_ell_cl('cl_00', 'gc', 'sz', ell, c_ell, window=wins)
with tempfile.TemporaryDirectory() as tmpdir:
filename = os.path.join(tmpdir, 'test.sacc')
s.save_fits(filename)
s2 = sacc.Sacc.load_fits(filename)
assert len(s2) == 30
l, cl, ind = s2.get_ell_cl('cl_00', 'gc', 'sz',
return_ind=True)
w = s2.get_bandpower_windows(ind)
assert np.all(cl == c_ell)
assert w.weight.shape == (n_ell_large, n_ell)
@pytest.mark.parametrize("vv,ncl,ntr",
[('0.2.0', 2, 2),
('0.3.0', 3, 2),
('0.4.2', 6, 5)])
def test_legacy_format(vv, ncl, ntr):
print(vv, ncl, ntr)
local_file_name = get_from_wiki(
f'https://github.com/LSSTDESC/sacc/wiki/legacy_files/dummy_v{vv}.fits')
s = sacc.Sacc.load_fits(local_file_name)
assert len(s.mean) == ncl * 100
assert len(s.tracers) == ntr
|
py | 7dff20c1ecd9299028aec1982d31a6cc9fe54faf | from tests.integration.base import DBTIntegrationTest, FakeArgs, use_profile
class TestSelectionExpansion(DBTIntegrationTest):
@property
def schema(self):
return "test_incremental_schema"
@property
def models(self):
return "models"
@property
def project_config(self):
return {
"config-version": 2,
"test-paths": ["tests"]
}
def list_tests_and_assert(self, include, exclude, expected_tests):
list_args = ['ls', '--resource-type', 'test']
if include:
list_args.extend(('--select', include))
if exclude:
list_args.extend(('--exclude', exclude))
listed = self.run_dbt(list_args)
print(listed)
assert len(listed) == len(expected_tests)
test_names = [name.split('.')[-1] for name in listed]
assert sorted(test_names) == sorted(expected_tests)
def run_tests_and_assert(
self, include, exclude, expected_tests, compare_source, compare_target
):
run_args = ['run']
if include:
run_args.extend(('--models', include))
results_one = self.run_dbt(run_args)
results_two = self.run_dbt(run_args)
self.assertEqual(len(results_one), 3)
self.assertEqual(len(results_two), 3)
test_args = ['test']
if include:
test_args.extend(('--models', include))
if exclude:
test_args.extend(('--exclude', exclude))
results = self.run_dbt(test_args)
tests_run = [r.node.name for r in results]
assert len(tests_run) == len(expected_tests)
assert sorted(tests_run) == sorted(expected_tests)
self.assertTablesEqual(compare_source, compare_target)
def run_incremental_ignore(self):
select = 'model_a incremental_ignore incremental_ignore_target'
compare_source = 'incremental_ignore'
compare_target = 'incremental_ignore_target'
exclude = None
expected = [
'select_from_a',
'select_from_incremental_ignore',
'select_from_incremental_ignore_target',
'unique_model_a_id',
'unique_incremental_ignore_id',
'unique_incremental_ignore_target_id'
]
self.list_tests_and_assert(select, exclude, expected)
self.run_tests_and_assert(select, exclude, expected, compare_source, compare_target)
def run_incremental_append_new_columns(self):
select = 'model_a incremental_append_new_columns incremental_append_new_columns_target'
compare_source = 'incremental_append_new_columns'
compare_target = 'incremental_append_new_columns_target'
exclude = None
expected = [
'select_from_a',
'select_from_incremental_append_new_columns',
'select_from_incremental_append_new_columns_target',
'unique_model_a_id',
'unique_incremental_append_new_columns_id',
'unique_incremental_append_new_columns_target_id'
]
self.list_tests_and_assert(select, exclude, expected)
self.run_tests_and_assert(select, exclude, expected, compare_source, compare_target)
def run_incremental_append_new_columns_remove_one(self):
select = 'model_a incremental_append_new_columns_remove_one incremental_append_new_columns_remove_one_target'
compare_source = 'incremental_append_new_columns_remove_one'
compare_target = 'incremental_append_new_columns_remove_one_target'
exclude = None
expected = [
'select_from_a',
'select_from_incremental_append_new_columns_remove_one',
'select_from_incremental_append_new_columns_remove_one_target',
'unique_model_a_id',
'unique_incremental_append_new_columns_remove_one_id',
'unique_incremental_append_new_columns_remove_one_target_id'
]
self.run_tests_and_assert(select, exclude, expected, compare_source, compare_target)
def run_incremental_sync_all_columns(self):
select = 'model_a incremental_sync_all_columns incremental_sync_all_columns_target'
compare_source = 'incremental_sync_all_columns'
compare_target = 'incremental_sync_all_columns_target'
exclude = None
expected = [
'select_from_a',
'select_from_incremental_sync_all_columns',
'select_from_incremental_sync_all_columns_target',
'unique_model_a_id',
'unique_incremental_sync_all_columns_id',
'unique_incremental_sync_all_columns_target_id'
]
self.list_tests_and_assert(select, exclude, expected)
self.run_tests_and_assert(select, exclude, expected, compare_source, compare_target)
def run_incremental_fail_on_schema_change(self):
select = 'model_a incremental_fail'
self.run_dbt(['run', '--models', select, '--full-refresh'])
results = self.run_dbt(['run', '--models', select], expect_pass=False)
self.assertIn('Compilation Error', results[1].message)
@use_profile('redshift')
def test__redshift__run_incremental_ignore(self):
self.run_incremental_ignore()
@use_profile('redshift')
def test__redshift__run_incremental_append_new_columns(self):
self.run_incremental_append_new_columns()
self.run_incremental_append_new_columns_remove_one()
@use_profile('redshift')
def test__redshift__run_incremental_sync_all_columns(self):
self.run_incremental_sync_all_columns()
@use_profile('redshift')
def test__redshift__run_incremental_fail_on_schema_change(self):
self.run_incremental_fail_on_schema_change()
|
py | 7dff21be9f15dd548d1d81e9f664d25c7d2913f5 | #!/bin/python
""" Healthcheck script to run inside docker
Example of usage in a Dockerfile
```
COPY --chown=scu:scu docker/healthcheck.py docker/healthcheck.py
HEALTHCHECK --interval=30s \
--timeout=30s \
--start-period=1s \
--retries=3 \
CMD python3 docker/healthcheck.py http://localhost:8000/
```
Q&A:
1. why not to use curl instead of a python script?
- SEE https://blog.sixeyed.com/docker-healthchecks-why-not-to-use-curl-or-iwr/
"""
import os
import sys
from urllib.request import urlopen
SUCCESS, UNHEALTHY = 0, 1
# Disabled if boots with debugger (e.g. debug, pdb-debug, debug-ptvsd, etc)
ok = "debug" in os.environ.get("SC_BOOT_MODE", "").lower()
# Queries host
# pylint: disable=consider-using-with
ok = (
ok
or urlopen(
"{host}{baseurl}".format(
host=sys.argv[1], baseurl=os.environ.get("SIMCORE_NODE_BASEPATH", "")
) # adds a base-path if defined in environ
).getcode()
== 200
)
sys.exit(SUCCESS if ok else UNHEALTHY)
|
py | 7dff21c71c2d46687af98aa15be782130a3f8cb6 | import numpy as np
np.random.seed(0)
def sigmoid(xvec):
""" Compute the sigmoid function """
# Cap -xvec, to avoid overflow
# Undeflow is okay, since it get set to zero
if isinstance(xvec, (list, np.ndarray)):
xvec[xvec < -100] = -100
elif xvec < -100:
xvec = -100
vecsig = 1.0 / (1.0 + np.exp(np.negative(xvec)))
return vecsig
def gen1(length, realization, weight_mu, weight_sigma, feature_num=25,cts_A=True, cts_B=True, cts_C=True):
'''
:param length: of A,B,C
:param feature_num: of X
:param cts_A:
:param cts_B:
:param cts_C:
:return:
'''
# mu and sigma for generating Ai,Bi,Ci
mu_a = np.random.normal(5, 20, length[0])
sigma_a = np.random.gamma(2, 0.5, length[0])
mu_b = np.random.normal(7, 15, length[1])
sigma_b = np.random.gamma(2, 0.5, length[1])
mu_c = np.random.normal(3, 17, length[2])
sigma_c = np.random.gamma(2, 0.5, length[2])
mu = [mu_a, mu_b, mu_c]
sigma = [sigma_a, sigma_b, sigma_c]
# shape_A=(length[0],1)
A = np.random.normal(mu[0], sigma[0], length[0])
B = np.random.normal(mu[1], sigma[1], length[1])
C = np.random.normal(mu[2], sigma[2], length[2])
############################################## 2
# generate 25 different sets of weights for each X_i
X_mu = []
X_sigma = []
# average Ai,Bi,Ci
average = [np.average(A), np.average(B), np.average(C)]
for i in xrange(feature_num):
X_mu.append( np.dot(average,weight_mu[i]) )
# try to make sigma small !!!
X_sigma.append( np.dot(average,weight_sigma[i]))
# normalize sigma
X_sigma = np.divide(X_sigma,np.sqrt((np.sum(np.asarray(X_sigma)**2))))
X_sigma = np.abs(X_sigma)
X = []
# for 100 realization
for j in xrange(realization):
X.append(np.random.normal(X_mu, X_sigma, feature_num))
# X is a matrix 100row, 25 column
############################################## 3
# weights for T
# random t
t = []
# global sss
for i in xrange(realization):
weights = [np.random.normal(-0.3,2,1), np.random.normal(0.7,1,1)]
p = sigmoid(np.dot(np.reshape(weights,(2,)), average[0:2]))
ti = np.random.binomial(1, p, 1)
t.append( ti )
# sss+=ti
# for the same patient we have the same t
#t = [t.astype('int64')]*realization
############################################## 4
yf = []
ycf = []
for i in range(realization):
if t[0] == 0:
weights_alpha = [7, 7]
weights_beta = [0.4, 0.04]
a = np.dot([np.average(B), np.average(C)], weights_alpha)
b = np.dot([np.var(B), np.var(C)], weights_beta)
alpha = np.abs(np.divide(np.square(a), b))
beta = np.abs(np.divide(b, a))
yf.append(np.random.gamma(alpha, beta, 1) - 1)
ycf.append(np.random.gamma(alpha, beta, 1))
else:
weights_alpha = [5, 0.5]
weights_beta = [0.5, 0.07]
a = np.dot([np.average(B), np.average(C)], weights_alpha)
b = np.dot([np.var(B), np.var(C)], weights_beta)
alpha = np.abs(np.divide(np.square(a), b))
beta = np.abs(np.divide(b, a))
yf.append(np.random.gamma(alpha, beta, 1)-1)
ycf.append(np.random.gamma(alpha, beta, 1))
# X is 100 row * 25 colomn
# t is 1*100, yf is 1*100, ycf is 1*100
return [X, t, yf, ycf]
def generate_full_data(sample_size,realization):
sample_x = []
sample_t = []
sample_yf = []
sample_ycf = []
mu0 = []
mu1 = []
# generate random weights
weight_mu = []
weight_sigma = []
for j in range(25):# feature number
v = np.random.uniform(-5, 5, 3)
weight_mu.append(np.divide(v, np.sum(v)))
v = np.random.uniform(0, 1, 3)
weight_sigma.append(np.divide(v, np.sum(v)))
for i in range(sample_size):
[X, t, yf, ycf] = gen1([10,15,20],realization,weight_mu,weight_sigma )
sample_x.append(X)
sample_t.append(t)
sample_yf.append(yf)
sample_ycf.append(ycf)
if t == 1: # is this a problem?
mu1.append(yf)
mu0.append(ycf)
else:
mu1.append(ycf)
mu0.append(yf)
sample_x = np.reshape(sample_x, (sample_size, 25, realization))
sample_t = np.reshape(sample_t, (sample_size, realization))
sample_yf = np.reshape(sample_yf, (sample_size, realization))
sample_ycf = np.reshape(sample_ycf, (sample_size, realization))
mu0 = np.reshape(mu0,(sample_size,realization))
mu1 = np.reshape(mu1,(sample_size,realization))
ate = np.array(4)
yadd = np.array(0)
ymul = np.array(1)
return [sample_x, sample_t, sample_yf, sample_ycf, mu0, mu1, ate, yadd, ymul]
# sss = 0
realization = 100
#q = gen1([5,5,5])
q = generate_full_data(1000,realization)
#print q[2]
np.savez('./data/synthetic_train_rtsy_%d.npz'%realization, x=q[0], t= q[1], yf=q[2], ycf=q[3], mu0=q[4],
mu1=q[5], ate=q[6], yadd=q[7], ymul=q[8])
# print sss
# sss = 0
np.random.seed(1)
q = generate_full_data(1000,realization)
np.savez('./data/synthetic_test_rtsy_%d.npz'%realization, x=q[0], t= q[1], yf=q[2], ycf=q[3], mu0=q[4],
mu1=q[5], ate=q[6], yadd=q[7], ymul=q[8])
# print sss
|
py | 7dff21d06f9c2d2d7de59a2275406a55103596a6 | """
WSGI config for paintapp project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'paintapp.settings')
application = get_wsgi_application()
|
py | 7dff22882b1d297d65a610ffd73c32094550ed34 | from django.urls import path
from .views import *
urlpatterns = [
path('api/users', UserList.as_view(), name = 'users_list'),
#path('api/create_users', UserCreate.as_view(), name = 'user_create'),
] |
py | 7dff228b40fa48265d4658c8846a75777bd6f022 | import kurisu.nyaa, kurisu.tips, kurisu.prefs
import sqlite3, time, os.path
from discord.ext import commands
class SteinsGate:
"""Команды, связанные с Steins;Gate"""
client = None
def __init__(self, bot):
self.client = bot
@commands.command()
async def tips(self, *tip: str):
"""Поиск по TIPS Steins;Gate.
Аргументы:
-----------
tip: `str`
TIP, который нужно найти.
"""
tip = ' '.join(tip)
await kurisu.tips.search(tip, self.client)
@commands.command()
async def sg0(self, episode: int):
"""Выводит список .torrent файлов.
Аргументы:
-----------
episide: `int`
Номер запрашиваемого эпизода.
"""
tmpEmbed = kurisu.prefs.Embeds.new('SG0')
# Nyaa
res = {}
conn = sqlite3.connect('torr_db.sqlite3')
cursor = conn.cursor()
cursor.execute("select title from episodes where id = %s" % episode)
ep = cursor.fetchall()
if len(ep) == 0:
await self.client.say('```Такой серии нет и не будет.```')
return "Fuck"
for dl in kurisu.nyaa.nyaa_dls:
cursor.execute('select dl, link, seeders, leechers from torrents where episode = %s and dl = "%s"' % (episode, dl))
res[dl] = cursor.fetchall()
conn.close()
nyaaField = []
for tmp in list(res.values()):
if len(tmp) > 0:
tmp = tmp[0]
nyaaField.append('[%s](https://nyaa.si/download/%s.torrent) | %s/%s' % (tmp[0], tmp[1], tmp[2], tmp[3]))
if len(nyaaField) == 0:
nyaaField.append('Эпизода еще нет на nyaa.si')
tmpEmbed.add_field(name='nyaa.si', value='\n'.join(nyaaField), inline = True)
tmpEmbed.title = ep[0][0]
pt = kurisu.prefs.parse_time(time.localtime(os.path.getmtime('torr_db.sqlite3')))
pt = '%s в %s' % (pt[0], pt[1][:-3])
tmpEmbed.set_footer(text='Последнее обновление БД: %s' % pt)
await self.client.say(embed=tmpEmbed)
@commands.command()
async def tips0(self, *tip: str):
"""Поиск по TIPS Steins;Gate 0.
Аргументы:
-----------
tip: `str`
TIP, который нужно найти.
"""
tip = ' '.join(tip)
await kurisu.tips.search(tip, self.client, 0)
def setup(bot):
bot.add_cog(SteinsGate(bot))
|
py | 7dff23151386dc04d072411dc694bc6ad4fb5f55 | # (c) Copyright 2014-2016 Hewlett-Packard Development Company, L.P.
#
# 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.
import socket
from keystoneauth1 import loading as kaloading
from freezerclient import utils
from freezerclient.v1.managers import actions
from freezerclient.v1.managers import backups
from freezerclient.v1.managers import clients
from freezerclient.v1.managers import jobs
from freezerclient.v1.managers import sessions
FREEZER_SERVICE_TYPE = 'backup'
class Client(object):
"""Client for the OpenStack Disaster Recovery v1 API.
"""
def __init__(self, token=None, username=None, password=None,
tenant_name=None, auth_url=None, session=None, endpoint=None,
endpoint_type=None, opts=None, project_name=None,
user_domain_name=None, user_domain_id=None,
project_domain_name=None, project_domain_id=None,
cert=None, cacert=None, insecure=False, project_id=None):
"""
Initialize a new client for the Disaster Recovery v1 API.
:param token: keystone token
:param username: openstack username
:param password: openstack password
:param tenant_name: tenant
:param auth_url: keystone-api endpoint
:param session: keystone.Session
:param endpoint: freezer-api endpoint
:param endpoint_type: type of endpoint
:param opts: a namespace to store all keystone data
:param project_name: only for version 3
:param user_domain_name: only for version 3
:param user_domain_id: only for version 3
:param project_domain_name: only for version 3
:param project_domain_id: only for version 3
:param insecure: The verification arguments to pass to requests.
These are of the same form as requests expects,
so True or False to verify (or not) against system
certificates or a path to a bundle or CA certs to
check against or None for requests to
attempt to locate and use certificates. (optional,
defaults to True)
:param cert: Path to cert
:param project_id: only for version 3
:return: freezerclient.Client
"""
self.project_id = project_id
if opts is None:
self.opts = utils.Namespace({})
self.opts.os_token = token or None
self.opts.os_username = username or None
self.opts.os_password = password or None
self.opts.os_tenant_name = tenant_name or None
self.opts.os_auth_url = auth_url or None
self.opts.os_backup_url = endpoint or None
self.opts.os_endpoint_type = endpoint_type or None
self.opts.os_project_name = project_name or None
self.opts.os_project_id = project_id or None
self.opts.os_user_domain_name = user_domain_name or None
self.opts.os_user_domain_id = user_domain_id or None
self.opts.os_project_domain_name = project_domain_name or None
self.opts.os_project_domain_id = project_domain_id or None
self.opts.os_cacert = cacert or None
self.opts.insecure = insecure
self.opts.cert = cert
else:
self.opts = opts
self.cert = cert
self.cacert = cacert or self.opts.os_cacert
self._session = session
verify = self.opts.os_cacert
if self.opts.insecure:
verify = False
self.validate()
self.project_id = project_id or self.get_project_id
self.jobs = jobs.JobManager(self, verify=verify)
self.clients = clients.ClientManager(self, verify=verify)
self.backups = backups.BackupsManager(self, verify=verify)
self.sessions = sessions.SessionManager(self, verify=verify)
self.actions = actions.ActionManager(self, verify=verify)
@utils.CachedProperty
def session(self):
if self._session:
return self._session
auth_type = 'password'
auth_kwargs = {
'auth_url': self.opts.os_auth_url,
'project_id': self.opts.os_project_id,
'project_name': self.opts.os_project_name,
'project_domain_id': self.opts.os_project_domain_id,
'project_domain_name': self.opts.os_project_domain_name,
}
if self.opts.os_username and self.opts.os_password:
auth_kwargs.update({
'username': self.opts.os_username,
'password': self.opts.os_password,
'tenant_name': self.opts.os_tenant_name,
'user_domain_id': self.opts.os_user_domain_id,
'user_domain_name': self.opts.os_user_domain_name,
})
elif self.opts.os_token:
auth_type = 'token'
auth_kwargs.update({
'token': self.opts.os_token,
})
loader = kaloading.get_plugin_loader(auth_type)
auth_plugin = loader.load_from_options(**auth_kwargs)
# Let keystoneauth do the necessary parameter conversions
session = kaloading.session.Session().load_from_options(
auth=auth_plugin, insecure=self.opts.insecure, cacert=self.cacert,
cert=self.cert)
return session
@utils.CachedProperty
def endpoint(self):
if self.opts.os_backup_url:
return self.opts.os_backup_url
else:
auth_ref = self.session.auth.get_auth_ref(self.session)
endpoint = auth_ref.service_catalog.url_for(
service_type=FREEZER_SERVICE_TYPE,
interface=self.opts.os_endpoint_type,
)
return endpoint
@property
def auth_token(self):
return self.session.get_token()
@property
def get_project_id(self):
return self.session.get_project_id()
@utils.CachedProperty
def client_id(self):
return '{0}_{1}'.format(self.session.get_project_id(),
socket.gethostname())
def validate(self):
"""Validate that the client objects gets created correctly.
:return: bool
"""
if not self._session and self.opts.os_auth_url is None:
raise Exception('OS_AUTH_URL should be provided.')
|
py | 7dff24698bf97b348dd3cd7eefe7ac88f63dbb74 | example = {'breakfast': {
'eggs': 1,
'spam': 2
}
} |
py | 7dff249894cd9a4521530dc4ad41f2385099c12d | #Raising Exceptions
def calculate_xfactor(x):
if x <= 0:
raise ValueError("Age Can not be zero or lease than zero")
return 10 / x
else:
print("executed else parth")
try:
calculate_xfactor(-1)
except ValueError as ex:
print(ex) |
py | 7dff2547f9929ea51c008e69d3f4a98ba3c86f2a | # importing required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# import GaussianNB
from sklearn.naive_bayes import GaussianNB
import cv2
# import warnings to remove any type of future warnings
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
# reading csv file and extracting class column to y.
dataf = pd.read_csv("Datasetinfectedhealthy.csv")
# extracting two features
X = dataf.drop(['imgid','fold num'], axis=1)
y = X['label']
X = X.drop('label', axis=1)
print("\nTraining dataset:-\n")
print(X)
log = pd.read_csv("datasetlog/Datasetunlabelledlog.csv")
log = log.tail(1)
X_ul = log.drop(['imgid','fold num'], axis=1)
print("\nTest dataset:-\n")
print(X_ul)
print("\n*To terminate press (q)*")
#X.plot(kind='scatter',x='feature1',y='feature2')
#plt.show()
Sum = 0
from sklearn.model_selection import train_test_split
'''
from sklearn.model_selection import train_test_split
for n in range(4):
x_train, Xi_test, y_train, yi_test = train_test_split(X, y, test_size=0.52, random_state=60)
if cv2.waitKey(1) == ord('q' or 'Q'): break
svclassifier = SVC(kernel='linear')
svclassifier.fit(x_train, y_train)
pred = svclassifier.predict(X_ul)
'''
for n in range(4):
x_train, Xi_test, y_train, yi_test = train_test_split(X, y, test_size=0.52, random_state=60)
if cv2.waitKey(1) == ord('q' or 'Q'): break
classifier = GaussianNB()
classifier.fit(x_train, y_train)
pred =classifier.predict(X_ul)
Sum = Sum + pred
print(pred)
print("\nprediction: %d" %int(Sum/4))
if(Sum < 2):
print("The leaf is sufficiently healthy!")
else:
print("The leaf is infected!")
print("\nKeypress on any image window to terminate")
#from sklearn.metrics import classification_report, confusion_matrix
#print(classification_report(yi_test,y_pred))
#print "\n Average precision percentage: %.2f" %avg_pred + "%"
cv2.waitKey(0)
|
py | 7dff284ba8c3b8def671f13b064630d09c7a40c6 | # coding: utf-8
"""
ESP Documentation
The Evident Security Platform API (version 2.0) is designed to allow users granular control over their Amazon Web Service security experience by allowing them to review alerts, monitor signatures, and create custom signatures.
OpenAPI spec version: v2_sdk
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import sys
import os
import re
# python 2 and python 3 compatibility library
from six import iteritems
from ..configuration import Configuration
from ..api_client import ApiClient
class StatSignaturesApi(object):
"""
NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
Ref: https://github.com/swagger-api/swagger-codegen
"""
def __init__(self, api_client=None):
config = Configuration()
if api_client:
self.api_client = api_client
else:
if not config.api_client:
config.api_client = ApiClient()
self.api_client = config.api_client
def list_for_stat(self, stat_id, **kwargs):
"""
Get a list of statistics for signatures
A successful call to this API returns all the statistics of all the signatures for a report identified by the stat_id parameter. Said report contains all statistics for this alert triggered from signatures contained in all signatures for the selected hour.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a `callback` function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_for_stat(stat_id, callback=callback_function)
:param callback function: The callback function
for asynchronous request. (optional)
:param int stat_id: The ID of the stat to retrieve signature statistics for (required)
:param str include: Related objects that can be included in the response: signature, stat See Including Objects for more information.
:param dict(str, str) filter: Filter Params for Searching. Equality Searchable Attributes: [stat_id, type_id]
:param str page: Page Number and Page Size. Number is the page number of the collection to return, size is the number of items to return per page.
:return: PaginatedCollection
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('callback'):
return self.list_for_stat_with_http_info(stat_id, **kwargs)
else:
(data) = self.list_for_stat_with_http_info(stat_id, **kwargs)
return data
def list_for_stat_with_http_info(self, stat_id, **kwargs):
"""
Get a list of statistics for signatures
A successful call to this API returns all the statistics of all the signatures for a report identified by the stat_id parameter. Said report contains all statistics for this alert triggered from signatures contained in all signatures for the selected hour.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a `callback` function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_for_stat_with_http_info(stat_id, callback=callback_function)
:param callback function: The callback function
for asynchronous request. (optional)
:param int stat_id: The ID of the stat to retrieve signature statistics for (required)
:param str include: Related objects that can be included in the response: signature, stat See Including Objects for more information.
:param dict(str, str) filter: Filter Params for Searching. Equality Searchable Attributes: [stat_id, type_id]
:param str page: Page Number and Page Size. Number is the page number of the collection to return, size is the number of items to return per page.
:return: PaginatedCollection
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stat_id', 'include', 'filter', 'page']
all_params.append('callback')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method list_for_stat" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stat_id' is set
if ('stat_id' not in params) or (params['stat_id'] is None):
raise ValueError("Missing the required parameter `stat_id` when calling `list_for_stat`")
collection_formats = {}
resource_path = '/api/v2/stats/{stat_id}/signatures.json_api'.replace('{format}', 'json_api')
path_params = {}
if 'stat_id' in params:
path_params['stat_id'] = params['stat_id']
query_params = {}
if 'include' in params:
query_params['include'] = params['include']
header_params = {}
form_params = []
local_var_files = {}
if 'filter' in params:
form_params.append(('filter', params['filter']))
if 'page' in params:
form_params.append(('page', params['page']))
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.\
select_header_accept(['application/vnd.api+json'])
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.\
select_header_content_type(['application/vnd.api+json'])
# Authentication setting
auth_settings = []
return self.api_client.call_api(resource_path, 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PaginatedCollection',
auth_settings=auth_settings,
callback=params.get('callback'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def show(self, id, **kwargs):
"""
Show a single Stat Signature
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a `callback` function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.show(id, callback=callback_function)
:param callback function: The callback function
for asynchronous request. (optional)
:param int id: Stat Signature ID (required)
:param str include: Related objects that can be included in the response: signature, stat See Including Objects for more information.
:return: StatSignature
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('callback'):
return self.show_with_http_info(id, **kwargs)
else:
(data) = self.show_with_http_info(id, **kwargs)
return data
def show_with_http_info(self, id, **kwargs):
"""
Show a single Stat Signature
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a `callback` function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.show_with_http_info(id, callback=callback_function)
:param callback function: The callback function
for asynchronous request. (optional)
:param int id: Stat Signature ID (required)
:param str include: Related objects that can be included in the response: signature, stat See Including Objects for more information.
:return: StatSignature
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['id', 'include']
all_params.append('callback')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method show" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'id' is set
if ('id' not in params) or (params['id'] is None):
raise ValueError("Missing the required parameter `id` when calling `show`")
collection_formats = {}
resource_path = '/api/v2/stats/signatures/{id}.json_api'.replace('{format}', 'json_api')
path_params = {}
if 'id' in params:
path_params['id'] = params['id']
query_params = {}
if 'include' in params:
query_params['include'] = params['include']
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.\
select_header_accept(['application/vnd.api+json'])
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.\
select_header_content_type(['application/vnd.api+json'])
# Authentication setting
auth_settings = []
return self.api_client.call_api(resource_path, 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='StatSignature',
auth_settings=auth_settings,
callback=params.get('callback'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
|
py | 7dff285c77745428b41746510ec1bf25e3ca8200 | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/master/config
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
import sys
# sys.path.insert(0, os.path.abspath('.'))
from unittest.mock import MagicMock
# Mock modules
class Mock(MagicMock):
@classmethod
def __getattr__(cls, name):
return MagicMock()
MOCK_MODULES = [
'glfw',
'sdl2',
'sdl2.ext',
'sdl2.video',
'pyglet',
'pyglet.window',
'PyQt5',
'PyQt5.QtCore',
'QtCore',
'QtOpenGL',
'QtWidgets',
'PySide2',
'PySide2.QtCore',
'pywavefront',
'pywavefront.obj',
'trimesh',
]
sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
# -- Project information -----------------------------------------------------
project = 'moderngl-window'
copyright = '2019, Einar Forselv'
author = 'Einar Forselv'
# The short X.Y version
version = '2.1.0'
# The full version, including alpha/beta/rc tags
release = version
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.doctest',
'sphinx.ext.coverage',
'sphinx.ext.viewcode',
'sphinxcontrib.napoleon',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = None
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
# html_sidebars = {}
# -- Options for HTMLHelp output ---------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'moderngl-windowdoc'
# -- Options for LaTeX output ------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'moderngl-window.tex', 'moderngl\\_window Documentation',
'Einar Forselv', 'manual'),
]
# -- Options for manual page output ------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'moderngl-window', 'moderngl-window Documentation',
[author], 1)
]
# -- Options for Texinfo output ----------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'moderngl-window', 'moderngl-window Documentation',
author, 'moderngl-window', 'A cross platform helper library for ModernGL making window creation and resource loading simple',
'Miscellaneous'),
]
# -- Options for Epub output -------------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#
# epub_identifier = ''
# A unique identification for the text.
#
# epub_uid = ''
# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']
# -- Extension configuration -------------------------------------------------
|
py | 7dff28715bb8152ed0340ed60686acdf9a9f5bf6 | # ### 1.5 function that post process the ccs results
import numpy as np
import pandas as pd
# define a function that could calculate the overall annual emission and lock emission
def bau_ccs_post (df):
coal_annual_existing_emission = df.loc[:,('coal_power_annual_emission_existing')].values
coal_annual_new_emission = df.loc[:,('coal_power_annual_emission_new')].values
gas_annual_existing_emission = df.loc[:,('gas_power_annual_emission_existing')].values
gas_annual_new_emission = df.loc[:,('gas_power_annual_emission_new')].values
oil_annual_existing_emission = df.loc[:,('oil_power_annual_emission_existing')].values
oil_annual_new_emission = df.loc[:,('oil_power_annual_emission_new')].values
coal_lock_existing_emission = df.loc[:,('coal_power_lock_emission_existing')].values
coal_lock_new_emission = df.loc[:,('coal_power_lock_emission_new')].values
gas_lock_existing_emission = df.loc[:,('gas_power_lock_emission_existing')].values
gas_lock_new_emission = df.loc[:,('gas_power_lock_emission_new')].values
oil_lock_existing_emission = df.loc[:,('oil_power_lock_emission_existing')].values
oil_lock_new_emission = df.loc[:,('oil_power_lock_emission_new')].values
coal_overall_lock_emission = np.zeros(shape=(36))
gas_overall_lock_emission = np.zeros(shape=(36))
oil_overall_lock_emission = np.zeros(shape=(36))
coal_overall_annual_emission = np.zeros(shape=(36))
gas_overall_annual_emission = np.zeros(shape=(36))
oil_overall_annual_emission = np.zeros(shape=(36))
for i in range(36):
coal_annual_exisitng = coal_annual_existing_emission[i]
gas_annual_exisitng = gas_annual_existing_emission[i]
oil_annual_exisitng = oil_annual_existing_emission[i]
coal_annual_added = 0
gas_annual_added = 0
oil_annual_added = 0
for j in range(i+1):
coal_annual_new = coal_annual_new_emission[j]
coal_annual_added = coal_annual_added + coal_annual_new
gas_annual_new = gas_annual_new_emission[j]
gas_annual_added = gas_annual_added + gas_annual_new
oil_annual_new = oil_annual_new_emission[j]
oil_annual_added = oil_annual_added + oil_annual_new
coal_overall_annual_emission[i] = coal_annual_exisitng + coal_annual_added
df.loc[:,('coal_annual_emission')] = coal_overall_annual_emission
gas_overall_annual_emission[i] = gas_annual_exisitng + gas_annual_added
df.loc[:,('gas_annual_emission')] = gas_overall_annual_emission
oil_overall_annual_emission[i] = oil_annual_exisitng + oil_annual_added
df.loc[:,('oil_annual_emission')] = oil_overall_annual_emission
for i in range(36):
coal_lock_exisitng = coal_lock_existing_emission[i]
gas_lock_exisitng = gas_lock_existing_emission[i]
oil_lock_exisitng = oil_lock_existing_emission[i]
coal_lock_added = 0
gas_lock_added = 0
oil_lock_added = 0
for j in range(i+1):
coal_lock_new = coal_lock_new_emission[j]* (1-0.025*(i-j))
coal_lock_added = coal_lock_added + coal_lock_new
gas_lock_new = gas_lock_new_emission[j]* (1-0.025*(i-j))
gas_lock_added = gas_lock_added + gas_lock_new
oil_lock_new = oil_lock_new_emission[j]* (1-0.025*(i-j))
oil_lock_added = oil_lock_added + oil_lock_new
coal_overall_lock_emission[i] = coal_lock_exisitng + coal_lock_added
df.loc[:,('coal_lock_emission')] = coal_overall_lock_emission
gas_overall_lock_emission[i] = gas_lock_exisitng + gas_lock_added
df.loc[:,('gas_lock_emission')] = gas_overall_lock_emission
oil_overall_lock_emission[i] = oil_lock_exisitng + oil_lock_added
df.loc[:,('oil_lock_emission')] = oil_overall_lock_emission
return df
# define a function that could select the useful columns from the table
def ccs_results (ccs):
ccs_cols = ['year',
'coal_power_capacity_GW','coal_power_capacity_existing','coal_power_capacity_new',
'coal_annual_emission','coal_power_annual_emission_existing','coal_power_annual_emission_new',
'coal_lock_emission','coal_power_lock_emission_existing','coal_power_lock_emission_new',
'gas_power_capacity_GW','gas_power_capacity_existing','gas_power_capacity_new',
'gas_annual_emission','gas_power_annual_emission_existing','gas_power_annual_emission_new',
'gas_lock_emission','gas_power_lock_emission_existing','gas_power_lock_emission_new',
'oil_power_capacity_GW','oil_power_capacity_existing','oil_power_capacity_new',
'oil_annual_emission','oil_power_annual_emission_existing','oil_power_annual_emission_new',
'oil_lock_emission','oil_power_lock_emission_existing','oil_power_lock_emission_new',
'coal_power_capacity_new1','coal_power_annual_emission_new1','coal_power_annual_emission_new1',
'coal_power_capacity_new2','coal_power_annual_emission_new2','coal_power_annual_emission_new2',
'gas_power_capacity_new1','gas_power_annual_emission_new1','gas_power_annual_emission_new1',
'gas_power_capacity_new2','gas_power_annual_emission_new2','gas_power_annual_emission_new2',
'oil_power_capacity_new1','oil_power_annual_emission_new1','oil_power_annual_emission_new1',
'oil_power_capacity_new2','oil_power_annual_emission_new2','oil_power_annual_emission_new2']
ccs = ccs[ccs_cols]
return ccs |
py | 7dff2aadd7014b3c777239c2f822bf4ad5dbb018 | def face_count(imagepath):
import cv2
import sys
cascPath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascPath)
image = cv2.imread(imagepath)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=3, # to tune the face count
minSize=(30, 30)
)
print("Found {0} faces!".format(len(faces)))
# Draw a rectangle around the faces
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.imshow("Faces found", image)
cv2.waitKey(0)
img_path="F:\\ComputerVision\\Faces_Count\\Images\\crowd-1.jpg"
face_count(img_path)
|
py | 7dff2b9475636e38a7646bcf28e7ade68a405647 |
# Import the backtrader platform
import backtrader as bt
import math
from backtesting.strategies.basic_strategy import BasicStrategy
# Create a Stratey
class SimpleMovingAverage(BasicStrategy):
params = (
# period for the fast Moving Average
('p1', 50),
# period for the slow moving average
('p2', 200),
)
def __init__(self, cash_to_invest_in_asset):
BasicStrategy.__init__(self, cash_to_invest_in_asset)
# For the moving average strategy
sma1 = bt.indicators.SMA(period=self.p.p1)
sma2 = bt.indicators.SMA(period=self.p.p2)
self.lines.signal = sma1 - sma2
def next(self):
# Simply log the closing price of the series from the reference
self.log('Close, %.2f' % self.dataclose[0])
# Check if an order is pending ... if yes, we cannot send a 2nd one
if self.order:
return
# Check if we are in the market
if not self.position:
if self.lines.signal > 0:
# BUY, BUY, BUY!!! (with default parameters)
self.log('BUY CREATE, %.2f' % self.dataclose[0])
# Keep track of the created order to avoid a 2nd order
self.num_stocks_bought = math.ceil(self.amount_money_invested / self.dataclose[0])
self.order = self.buy(size=self.num_stocks_bought)
else:
if self.lines.signal < 0:
# SELL, SELL, SELL!!! (with all possible default parameters)
self.log('SELL CREATE, %.2f' % self.dataclose[0])
# Keep track of the created order to avoid a 2nd order
self.order = self.sell(size=self.num_stocks_bought)
self.num_stocks_bought = 0
|
py | 7dff2d12062c5ef71e0405359576fa02fb79cafd | from django.db import models, migrations
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
("auth", "0006_require_contenttypes_0002"),
]
operations = [
migrations.CreateModel(
name="Booking",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("confirmedOn", models.DateTimeField(null=True, blank=True)),
("cancelledOn", models.DateTimeField(null=True, blank=True)),
("datePaid", models.DateTimeField(null=True, blank=True)),
("exempt_of_payment", models.BooleanField(default=False)),
(
"cancelledBy",
models.ForeignKey(
related_name="cancelled_bookings",
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
on_delete=models.deletion.SET_NULL,
),
),
],
options={"ordering": ["id"]},
),
migrations.CreateModel(
name="BookingOption",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"booking",
models.ForeignKey(
related_name="options",
to="oneevent.Booking",
on_delete=models.deletion.CASCADE,
),
),
],
options={"ordering": ["option__choice__id", "option__id", "id"]},
),
migrations.CreateModel(
name="Choice",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(max_length=64)),
],
options={"ordering": ["id"]},
),
migrations.CreateModel(
name="Event",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(unique=True, max_length=64)),
("start", models.DateTimeField(help_text="Local start date and time")),
(
"end",
models.DateTimeField(
help_text="Local end date and time", null=True, blank=True
),
),
(
"city",
models.CharField(
help_text="Timezone of your event",
max_length=32,
choices=[
("Boston", "Boston"),
("Erding", "Erding"),
("London", "London"),
("Miami", "Miami"),
("Munich", "Munich"),
("Nice", "Nice"),
("Sydney", "Sydney"),
("Toronto", "Toronto"),
("UTC", "UTC"),
],
),
),
("description", models.TextField(blank=True)),
(
"pub_status",
models.CharField(
default="UNPUB",
help_text="Public: Visible and bookable by all; Restricted: "
"Visible and Bookable by invited groups; Private: "
"Visible by participant, bookable by all; "
"Unpublished: Visible by organisers, not bookable; "
"Archived: Not visible, not bookable",
max_length=8,
verbose_name="Publication status",
choices=[
("PUB", "Public"),
("REST", "Restricted"),
("PRIV", "Private"),
("UNPUB", "Unpublished"),
("ARCH", "Archived"),
],
),
),
(
"location_name",
models.CharField(
help_text="Venue of your event",
max_length=64,
null=True,
blank=True,
),
),
("location_address", models.TextField(null=True, blank=True)),
(
"booking_close",
models.DateTimeField(
help_text="Limit date and time for registering",
null=True,
blank=True,
),
),
(
"choices_close",
models.DateTimeField(
help_text="Limit date and time for changing choices",
null=True,
blank=True,
),
),
(
"max_participant",
models.PositiveSmallIntegerField(
default=0,
help_text="Maximum number of participants to this event (0 = "
"no limit)",
),
),
(
"price_for_employees",
models.DecimalField(default=0, max_digits=6, decimal_places=2),
),
(
"price_for_contractors",
models.DecimalField(default=0, max_digits=6, decimal_places=2),
),
(
"price_currency",
models.CharField(
max_length=3,
null=True,
verbose_name="Currency for prices",
blank=True,
),
),
(
"contractors_groups",
models.ManyToManyField(
related_name="contractors_for_event+",
verbose_name="Groups considered as Contractors",
to="auth.Group",
blank=True,
),
),
(
"employees_groups",
models.ManyToManyField(
related_name="employees_for_event+",
verbose_name="Groups considered as Employees",
to="auth.Group",
blank=True,
),
),
(
"organisers",
models.ManyToManyField(
related_name="events_organised",
to=settings.AUTH_USER_MODEL,
blank=True,
),
),
(
"owner",
models.ForeignKey(
related_name="events_owned",
to=settings.AUTH_USER_MODEL,
help_text="Main organiser",
on_delete=models.deletion.PROTECT,
),
),
],
),
migrations.CreateModel(
name="Message",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"category",
models.CharField(
max_length=8,
verbose_name="Reason",
choices=[
("QUERY", "Question"),
("COMMENT", "Comment"),
("BUG", "Bug report"),
("FEAT", "Feature request"),
("ADMIN", "Administration Request"),
],
),
),
("title", models.CharField(max_length=128)),
("text", models.TextField(max_length=2048)),
("created", models.DateTimeField(auto_now_add=True)),
("safe_content", models.BooleanField(default=False)),
(
"sender",
models.ForeignKey(
to=settings.AUTH_USER_MODEL, on_delete=models.deletion.CASCADE
),
),
(
"thread_head",
models.ForeignKey(
related_name="thread",
blank=True,
to="oneevent.Message",
null=True,
on_delete=models.deletion.CASCADE,
),
),
],
options={"ordering": ["-created"]},
),
migrations.CreateModel(
name="Option",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(max_length=256)),
("default", models.BooleanField(default=False)),
(
"choice",
models.ForeignKey(
related_name="options",
to="oneevent.Choice",
on_delete=models.deletion.CASCADE,
),
),
],
options={"ordering": ["choice__id", "id"]},
),
migrations.CreateModel(
name="Session",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(unique=True, max_length=64)),
("start", models.DateTimeField(help_text="Local start date and time")),
(
"end",
models.DateTimeField(
help_text="Local end date and time", null=True, blank=True
),
),
(
"max_participant",
models.PositiveSmallIntegerField(
default=0,
help_text="Maximum number of participants to this session (0 "
"= no limit)",
),
),
(
"event",
models.ForeignKey(
related_name="sessions",
to="oneevent.Event",
on_delete=models.deletion.CASCADE,
),
),
],
options={"ordering": ["event", "title"]},
),
migrations.AddField(
model_name="choice",
name="event",
field=models.ForeignKey(
related_name="choices",
to="oneevent.Event",
on_delete=models.deletion.CASCADE,
),
),
migrations.AddField(
model_name="bookingoption",
name="option",
field=models.ForeignKey(
blank=True,
to="oneevent.Option",
null=True,
on_delete=models.deletion.CASCADE,
),
),
migrations.AddField(
model_name="booking",
name="event",
field=models.ForeignKey(
related_name="bookings",
to="oneevent.Event",
on_delete=models.deletion.CASCADE,
),
),
migrations.AddField(
model_name="booking",
name="paidTo",
field=models.ForeignKey(
related_name="received_payments",
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
on_delete=models.deletion.SET_NULL,
),
),
migrations.AddField(
model_name="booking",
name="person",
field=models.ForeignKey(
related_name="bookings",
to=settings.AUTH_USER_MODEL,
on_delete=models.deletion.CASCADE,
),
),
migrations.AddField(
model_name="booking",
name="session",
field=models.ForeignKey(
related_name="bookings",
blank=True,
to="oneevent.Session",
null=True,
on_delete=models.deletion.CASCADE,
),
),
migrations.AlterUniqueTogether(
name="session", unique_together=set([("event", "title")]),
),
migrations.AlterUniqueTogether(
name="option", unique_together=set([("choice", "title")]),
),
migrations.AlterUniqueTogether(
name="choice", unique_together=set([("event", "title")]),
),
migrations.AlterUniqueTogether(
name="bookingoption", unique_together=set([("booking", "option")]),
),
migrations.AlterUniqueTogether(
name="booking", unique_together=set([("event", "person")]),
),
]
|
py | 7dff2d1dd62ad338361acc9bf77e1c96c278a074 | import _plotly_utils.basevalidators
class ShowticksuffixValidator(_plotly_utils.basevalidators.EnumeratedValidator):
def __init__(
self, plotly_name="showticksuffix", parent_name="contour.colorbar", **kwargs
):
super(ShowticksuffixValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "colorbars"),
values=kwargs.pop("values", ["all", "first", "last", "none"]),
**kwargs
)
|
py | 7dff2da70ef457c6e152447cc1b67140f43b821a | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
General utility code for building PyTorch-based agents in ParlAI.
Contains the following main utilities:
* TorchAgent class which serves as a useful parent class for other model agents
* Batch namedtuple which is the input type of the main abstract methods of
the TorchAgent class
* Output namedtuple which is the expected output type of the main abstract
methods of the TorchAgent class
* History class which handles tracking the dialogue state over the course of an episode.
See below for documentation on each specific tool.
"""
from typing import Dict, Any, Union, List, Tuple
from abc import ABC, abstractmethod
from copy import deepcopy
from collections import deque
import json
import random
import os
import torch
from torch import optim
from parlai.core.opt import Opt
from parlai.core.agents import Agent
from parlai.utils.thread import SharedTable
from parlai.core.dict import DictionaryAgent
from parlai.nn.lr_scheduler import ParlAILRScheduler
from parlai.core.message import Message
from parlai.utils.distributed import is_distributed
from parlai.utils.misc import AttrDict, warn_once
from parlai.utils.fp16 import (
fp16_apex_available,
fp16_optimizer_wrapper,
MemoryEfficientFP16Optimizer,
MemoryEfficientFP16Adam,
Adafactor,
)
from parlai.core.metrics import (
Metrics,
Metric,
GlobalAverageMetric,
GlobalSumMetric,
GlobalFixedMetric,
)
from parlai.utils.distributed import is_primary_worker
from parlai.utils.torch import argsort, compute_grad_norm, padded_tensor
class Batch(AttrDict):
"""
Batch is a namedtuple containing data being sent to an agent.
This is the input type of the train_step and eval_step functions.
Agents can override the batchify function to return an extended namedtuple
with additional fields if they would like, though we recommend calling the
parent function to set up these fields as a base.
:param text_vec:
bsz x seqlen tensor containing the parsed text data.
:param text_lengths:
list of length bsz containing the lengths of the text in same order as
text_vec; necessary for pack_padded_sequence.
:param label_vec:
bsz x seqlen tensor containing the parsed label (one per batch row).
:param label_lengths:
list of length bsz containing the lengths of the labels in same order as
label_vec.
:param labels:
list of length bsz containing the selected label for each batch row (some
datasets have multiple labels per input example).
:param valid_indices:
list of length bsz containing the original indices of each example in the
batch. we use these to map predictions back to their proper row, since e.g.
we may sort examples by their length or some examples may be invalid.
:param candidates:
list of lists of text. outer list has size bsz, inner lists vary in size
based on the number of candidates for each row in the batch.
:param candidate_vecs:
list of lists of tensors. outer list has size bsz, inner lists vary in size
based on the number of candidates for each row in the batch.
:param image:
list of image features in the format specified by the --image-mode arg.
:param observations:
the original observations in the batched order
"""
def __init__(
self,
text_vec=None,
text_lengths=None,
label_vec=None,
label_lengths=None,
labels=None,
valid_indices=None,
candidates=None,
candidate_vecs=None,
image=None,
observations=None,
**kwargs,
):
super().__init__(
text_vec=text_vec,
text_lengths=text_lengths,
label_vec=label_vec,
label_lengths=label_lengths,
labels=labels,
valid_indices=valid_indices,
candidates=candidates,
candidate_vecs=candidate_vecs,
image=image,
observations=observations,
**kwargs,
)
class Output(AttrDict):
"""
Output is an object containing agent predictions.
This is the expected return type of the train_step and eval_step functions,
though agents can choose to return None if they do not want to answer.
:param List[str] text:
list of strings of length bsz containing the predictions of the model
:param List[List[str]] text_candidates:
list of lists of length bsz containing ranked predictions of the model.
each sub-list is an ordered ranking of strings, of variable length.
"""
def __init__(self, text=None, text_candidates=None, **kwargs):
super().__init__(text=text, text_candidates=text_candidates, **kwargs)
class History(object):
"""
History handles tracking the dialogue state over the course of an episode.
History may also be used to track the history of any field.
:param field:
field in the observation to track over the course of the episode
(defaults to 'text')
:param vec_type:
specify a 'list' or 'deque' to save the history in this object
:param maxlen:
if `vec_type` is 'deque', this sets the maximum length of that object
:param p1_token:
token indicating 'person 1'; opt must have 'person_tokens' set to True
for this to be added
:param p1_token:
token indicating 'person 2'; opt must have 'person_tokens' set to True
for this to be added
:param dict_agent:
DictionaryAgent object for tokenizing the history
"""
def __init__(
self,
opt,
field='text',
vec_type='deque',
maxlen=None,
size=-1,
p1_token='__p1__',
p2_token='__p2__',
dict_agent=None,
):
self.field = field
self.dict = dict_agent
self.delimiter = opt.get('delimiter', '\n')
self.delimiter_tok = self.parse(self.delimiter)
self.size = size
self.split_on_newln = opt.get('split_lines', False)
self._global_end_token = opt.get('history_add_global_end_token', None)
if self._global_end_token is not None:
self._global_end_token = self.dict[self.dict.end_token]
# set up history objects
if vec_type != 'deque' and vec_type != 'list':
raise RuntimeError('Type {} is not supported for history'.format(vec_type))
self.vec_type = vec_type
self.max_len = maxlen
self.history_strings = []
self.history_raw_strings = []
self.history_vecs = []
# person token args
self.add_person_tokens = opt.get('person_tokens', False)
self.add_p1_after_newln = opt.get('add_p1_after_newln', False)
self.p1_token = p1_token
self.p2_token = p2_token
def parse(self, text):
"""
Tokenize text with the given dictionary.
"""
return self.dict.txt2vec(text)
def reset(self):
"""
Clear the history.
"""
self.history_raw_strings = []
self.history_strings = []
self.history_vecs = []
def _update_strings(self, text):
if self.size > 0:
while len(self.history_strings) >= self.size:
self.history_strings.pop(0)
self.history_strings.append(text)
def _update_raw_strings(self, text):
if self.size > 0:
while len(self.history_raw_strings) >= self.size:
self.history_raw_strings.pop(0)
self.history_raw_strings.append(text)
def _update_vecs(self, text):
if self.size > 0:
while len(self.history_vecs) >= self.size:
self.history_vecs.pop(0)
self.history_vecs.append(self.parse(text))
def add_reply(self, text):
"""
Add your own response to the history.
"""
self._update_raw_strings(text)
if self.add_person_tokens:
text = self._add_person_tokens(text, self.p2_token)
# update history string
self._update_strings(text)
# update history vecs
self._update_vecs(text)
def update_history(self, obs):
"""
Update the history with the given observation.
"""
if self.field in obs and obs[self.field] is not None:
if self.split_on_newln:
next_texts = obs[self.field].split('\n')
else:
next_texts = [obs[self.field]]
for text in next_texts:
self._update_raw_strings(text)
if self.add_person_tokens:
text = self._add_person_tokens(
obs[self.field], self.p1_token, self.add_p1_after_newln
)
# update history string
self._update_strings(text)
# update history vecs
self._update_vecs(text)
def get_history_str(self):
"""
Return the string version of the history.
"""
if len(self.history_strings) > 0:
return self.delimiter.join(self.history_strings)
return None
def get_history_vec(self):
"""
Return a vectorized version of the history.
"""
if len(self.history_vecs) == 0:
return None
if self.vec_type == 'deque':
history = deque(maxlen=self.max_len)
for vec in self.history_vecs[:-1]:
history.extend(vec)
history.extend(self.delimiter_tok)
history.extend(self.history_vecs[-1])
if self._global_end_token is not None:
history.extend([self._global_end_token])
else:
# vec type is a list
history = []
for vec in self.history_vecs[:-1]:
history += vec
history += self.delimiter_tok
history += self.history_vecs[-1]
if self._global_end_token is not None:
history += [self._global_end_token]
return history
def get_history_vec_list(self):
"""
Return a list of history vecs.
"""
return self.history_vecs
def _add_person_tokens(self, text, token, add_after_newln=False):
if add_after_newln:
split = text.split('\n')
split[-1] = token + ' ' + split[-1]
return '\n'.join(split)
else:
return token + ' ' + text
class TorchAgent(ABC, Agent):
"""
A provided abstract base agent for any model that wants to use Torch.
Exists to make it easier to implement a new agent.
Not necessary, but reduces duplicated code.
Many methods are intended to be either used as is when the default is
acceptable, or to be overriden and called with super(), with the extra
functionality added to the initial result. See the method comment for
recommended behavior.
This agent serves as a common framework for all ParlAI models which want
to use PyTorch.
"""
P1_TOKEN = '__p1__'
P2_TOKEN = '__p2__'
@classmethod
def optim_opts(self):
"""
Fetch optimizer selection.
By default, collects everything in torch.optim, as well as importing:
- qhm / qhmadam if installed from github.com/facebookresearch/qhoptim
Override this (and probably call super()) to add your own optimizers.
"""
# first pull torch.optim in
optims = {
k.lower(): v
for k, v in optim.__dict__.items()
if not k.startswith('__') and k[0].isupper()
}
try:
import apex.optimizers.fused_adam as fused_adam
import apex.optimizers.fused_lamb as fused_lamb
optims['fused_adam'] = fused_adam.FusedAdam
optims['fused_lamb'] = fused_lamb.FusedLAMB
except ImportError:
pass
try:
# https://openreview.net/pdf?id=S1fUpoR5FQ
from qhoptim.pyt import QHM, QHAdam
optims['qhm'] = QHM
optims['qhadam'] = QHAdam
except ImportError:
# no QHM installed
pass
# now pull in memory efficient implementations
optims['mem_eff_adam'] = MemoryEfficientFP16Adam
optims['adafactor'] = Adafactor
return optims
@staticmethod
def dictionary_class():
"""
Return the dictionary class that this agent expects to use.
Can be overriden if a more complex dictionary is required.
"""
return DictionaryAgent
@classmethod
def history_class(cls):
"""
Return the history class that this agent expects to use.
Can be overriden if a more complex history is required.
"""
return History
@classmethod
def add_cmdline_args(cls, argparser):
"""
Add the default commandline args we expect most agents to want.
"""
agent = argparser.add_argument_group('TorchAgent Arguments')
agent.add_argument(
'-i',
'--interactive-mode',
type='bool',
default=False,
help='Whether in full interactive mode or not, which means generating text or'
' retrieving from a full set of candidates, which is necessary to actually'
' do full dialogue. However, during training or quick validation (e.g. PPL for'
' generation or ranking a few candidates for ranking models) you might want these'
' set to off.'
' Typically, scripts can set their preferred default behavior at the start,'
' e.g. eval scripts.',
)
# pretrained embedding arguments
agent.add_argument(
'-emb',
'--embedding-type',
default='random',
choices=[
'random',
'glove',
'glove-fixed',
'fasttext',
'fasttext-fixed',
'fasttext_cc',
'fasttext_cc-fixed',
],
help='Choose between different strategies for initializing word '
'embeddings. Default is random, but can also preinitialize '
'from Glove or Fasttext. Preinitialized embeddings can also '
'be fixed so they are not updated during training.',
)
agent.add_argument(
'-embp',
'--embedding-projection',
default='random',
help='If pretrained embeddings have a different dimensionality '
'than your embedding size, strategy for projecting to the '
'correct size. If the dimensions are the same, this is '
'ignored unless you append "-force" to your choice.',
)
agent.add_argument(
'--fp16', type='bool', default=False, help='Use fp16 computations.'
)
agent.add_argument(
'--fp16-impl',
type=str,
default='apex',
choices=['apex', 'mem_efficient'],
help='Implementation of FP16 to use',
)
agent.add_argument(
'--force-fp16-tokens',
type='bool',
default=False,
hidden=True,
help='Add the special fp16 tokens even if not using fp16.',
)
# optimizer arguments
optim_group = agent.add_argument_group('Optimizer Arguments')
optim_group.add_argument(
'-opt',
'--optimizer',
default='sgd',
choices=cls.optim_opts(),
help='Choose between pytorch optimizers. Any member of torch.optim'
' should be valid.',
)
optim_group.add_argument(
'-lr', '--learningrate', type=float, default=1, help='Learning rate'
)
optim_group.add_argument(
'-clip',
'--gradient-clip',
type=float,
default=0.1,
help='gradient clipping using l2 norm',
)
optim_group.add_argument(
'--adam-eps',
type=float,
default=1e-8,
hidden=True,
help='Epsilon value for Adam optimizers. Set to 1e-6 if your '
'large model has stability issues, but prefer the default.',
)
optim_group.add_argument(
'--adafactor-eps',
default='1e-30,1e-3',
type='floats',
help='Epsilon values for adafactor optimizer: regularization '
'constants for square gradient and parameter scale respectively',
recommended='1e-30,1e-3',
)
optim_group.add_argument(
'-mom',
'--momentum',
default=0,
type=float,
help='if applicable, momentum value for optimizer.',
)
optim_group.add_argument(
'--nesterov',
default=True,
type='bool',
help='if applicable, whether to use nesterov momentum.',
)
optim_group.add_argument(
'-nu',
'--nus',
default='0.7',
type='floats',
help='if applicable, nu value(s) for optimizer. can use a single '
'value like 0.7 or a comma-separated tuple like 0.7,1.0',
)
optim_group.add_argument(
'-beta',
'--betas',
default='0.9,0.999',
type='floats',
help='if applicable, beta value(s) for optimizer. can use a single '
'value like 0.9 or a comma-separated tuple like 0.9,0.999',
)
optim_group.add_argument(
'-wdecay',
'--weight-decay',
type=float,
default=None,
help='Weight decay on the weights.',
)
# preprocessing arguments
agent.add_argument(
'-rc',
'--rank-candidates',
type='bool',
default=False,
help='Whether the model should parse candidates for ranking.',
)
agent.add_argument(
'-tr',
'--truncate',
default=-1,
type=int,
help='Truncate input lengths to increase speed / use less memory.',
)
agent.add_argument(
'--text-truncate',
type=int,
help='Text input truncation length: if not specified, this will '
'default to `truncate`',
)
agent.add_argument(
'--label-truncate',
type=int,
help='Label truncation length: if not specified, this will default '
'to `truncate`',
)
agent.add_argument(
'-histsz',
'--history-size',
default=-1,
type=int,
help='Number of past dialog utterances to remember.',
)
agent.add_argument(
'-pt',
'--person-tokens',
type='bool',
default=False,
help='add person tokens to history. adds __p1__ in front of input '
'text and __p2__ in front of past labels when available or '
'past utterances generated by the model. these are added to '
'the dictionary during initialization.',
)
agent.add_argument(
'--split-lines',
type='bool',
default=False,
help='split the dialogue history on newlines and save in separate '
'vectors',
)
agent.add_argument(
'--use-reply',
default='label',
hidden=True,
choices=['label', 'model', 'none'],
help='Which previous replies to use as history. If label, use '
'gold dataset replies. If model, use model\'s own replies. '
'If none, do not track replies in history.',
)
agent.add_argument(
'--add-p1-after-newln',
type='bool',
default=False,
hidden=True,
help='Add the other speaker token before the last newline in the '
'input instead of at the beginning of the input. this is '
'useful for tasks that include some kind of context before '
'the actual utterance (e.g. squad, babi, personachat).',
)
agent.add_argument(
'--delimiter',
type=str,
default='\n',
help='Join history lines with this token, defaults to newline',
)
agent.add_argument(
'--history-add-global-end-token',
type='nonestr',
default=None,
hidden=True,
choices=[None, 'end'],
help='Add special token to the end of history encoding.',
)
# GPU arguments
# these gpu options are all mutually exclusive, and should error if the
# user tries to present multiple of them
gpugroup = agent.add_mutually_exclusive_group()
gpugroup.add_argument(
'-gpu', '--gpu', type=int, default=-1, help='which GPU to use'
)
gpugroup.add_argument(
'--no-cuda',
default=False,
action='store_true',
dest='no_cuda',
help='disable GPUs even if available. otherwise, will use GPUs if '
'available on the device.',
)
cls.dictionary_class().add_cmdline_args(argparser)
ParlAILRScheduler.add_cmdline_args(argparser)
def __init__(self, opt: Opt, shared=None):
"""
Initialize agent.
"""
super().__init__(opt, shared)
opt = self.opt
# Safety checkers to ensure TorchAgent assumptions aren't being violated.
self.__expecting_clear_history = False
self.__expecting_to_reply = False
# used for sharing metrics back to the teacher
self._local_metrics: Dict[str, List[Metric]] = {}
# we may want to temporarily disable local metrics, roughly similar to
# `with torch.no_grad`. See TorchGeneratorAgent._init_cuda_buffer for
# example
self.__local_metrics_enabled = True
# check for cuda
self.use_cuda = not opt['no_cuda'] and torch.cuda.is_available()
if self.use_cuda:
if not shared:
print('[ Using CUDA ]')
if not shared and opt['gpu'] != -1:
torch.cuda.set_device(opt['gpu'])
# whether we're using multi-gpu, a few different ways. these are not
# supported by all models, but we can still keep track of the options
self.model_parallel = opt.get('model_parallel', False) and self.use_cuda
self.data_parallel = opt.get('data_parallel', False) and self.use_cuda
if self.data_parallel and is_distributed():
raise RuntimeError('Cannot combine --data-parallel and distributed mode.')
if self.model_parallel and self.data_parallel:
raise RuntimeError('Cannot combine --data-parallel and --model-parallel.')
# indicate whether using fp16
self.fp16 = self.use_cuda and self.opt.get('fp16', False)
if self.fp16:
# check that the implementation requested is available
self.fp16_impl = self.opt.get('fp16_impl', 'apex')
if self.fp16_impl == 'apex' and not fp16_apex_available():
self.fp16 = False
if shared is None:
# intitialize any important structures from scratch
self.dict = self.build_dictionary()
if opt.get('fp16') or opt.get('force_fp16_tokens'):
# Volta cores revert to FP32 hardware if tensors are not multiples
# of 8 in all dimensions. This INCLUDES the embeddings layer! As
# such, we need some extra magic to ensure the dictionary is padded
# with extra tokens to make it a multiple of 8.
from parlai.utils.torch import FP16_PAD_SIZE
if len(self.dict) % FP16_PAD_SIZE != 0:
for i in range(FP16_PAD_SIZE - len(self.dict) % FP16_PAD_SIZE):
self.dict['__FP16_PAD_{}__'.format(i)] = 1
# global_metrics keeps track of batch-level or global-level metrics
self.global_metrics = Metrics(opt.get('numthreads', 1) > 1, shared=None)
# self.metrics is there for legacy reasons
self.metrics: Dict[str, Any] = {}
else:
# copy initialized data from shared table
self.opt = shared['opt']
self.dict = shared['dict']
self.model = shared['model']
self.criterion = shared['criterion']
self.metrics = shared['metrics']
self.global_metrics = Metrics(
opt.get('numthreads', 1) > 1, shared=shared['global_metrics']
)
if opt.get('numthreads', 1) > 1:
torch.set_num_threads(1)
# Default to the class name, sans "Agent". child can override
self.id = type(self).__name__.replace("Agent", "")
# now set up any fields that all instances may need
self.EMPTY = torch.zeros(0, dtype=torch.long)
self.NULL_IDX = self.dict[self.dict.null_token]
self.START_IDX = self.dict[self.dict.start_token]
self.END_IDX = self.dict[self.dict.end_token]
# for gradient acumulation
self._number_grad_accum = 0
# for the LR scheduler
self._number_training_updates = 0
# fixed random seed
self.random = random.Random(42)
# can remember as few as zero utterances if desired
self.histsz = opt['history_size']
# truncate == 0 might give funny behavior
self.truncate = opt['truncate'] if opt['truncate'] >= 0 else None
text_truncate = opt.get('text_truncate') or opt['truncate']
self.text_truncate = text_truncate if text_truncate >= 0 else None
label_truncate = opt.get('label_truncate') or opt['truncate']
self.label_truncate = label_truncate if label_truncate >= 0 else None
# stores up to hist_utt past observations within current dialog
self.history = self.build_history()
self.is_training = False # track whether model is training
self.rank_candidates = opt['rank_candidates']
self.add_person_tokens = opt.get('person_tokens', False)
# set interactive mode or not according to options.
self.set_interactive_mode(opt.get('interactive_mode', False), shared)
def build_history(self):
"""
Return the constructed history object.
"""
return self.history_class()(
self.opt,
maxlen=self.text_truncate,
size=self.histsz,
p1_token=self.P1_TOKEN,
p2_token=self.P2_TOKEN,
dict_agent=self.dict,
)
def build_dictionary(self):
"""
Return the constructed dictionary, which will be set to self.dict.
If you need to add additional tokens to the dictionary, this is likely the right
place to do it.
"""
d = self.dictionary_class()(self.opt)
if self.opt.get('person_tokens'):
d[self.P1_TOKEN] = 999_999_999
d[self.P2_TOKEN] = 999_999_998
return d
def _get_init_model(self, opt: Opt, shared):
"""
Get model file to initialize with.
If `init_model` exits, we will return the path to that file and maybe
load dict file from that path. Otherwise, use `model_file.`
:return: path to load model from, whether we loaded from `init_model`
or not
"""
init_model = None
is_finetune = False
if not shared: # only do this on first setup
# first check load path in case we need to override paths
if opt.get('init_model') and os.path.isfile(opt['init_model']):
# check first for 'init_model' for loading model from file
init_model = opt['init_model']
is_finetune = True
if opt.get('model_file') and os.path.isfile(opt['model_file']):
# next check for 'model_file', this would override init_model
init_model = opt['model_file']
is_finetune = False
if (
opt.get('load_from_checkpoint')
and opt.get('init_model')
and opt['init_model'].endswith('.checkpoint')
):
# but if we're loading from a checkpoint, we should explicitly load
# from that point
init_model = opt['init_model']
is_finetune = False
if init_model is not None:
# if we are loading a model, should load its dict too
if os.path.isfile(init_model + '.dict') or opt['dict_file'] is None:
opt['dict_file'] = init_model + '.dict'
return init_model, is_finetune
@abstractmethod
def build_model(self):
"""
Construct the model and return it.
"""
raise NotImplementedError('not implemented for this class')
def _should_initialize_optimizer(self) -> bool:
"""
Used to indicate whether we should initialize an optimizer.
When this is off, we can save memory and use larger batches.
"""
if self.opt.get('interactive_mode'):
return False
datatype = self.opt.get('datatype', '')
is_train = 'train' in datatype and 'evalmode' not in datatype
return is_train or self.opt.get('numthreads', 1) > 1
def init_optim(self, params, optim_states=None, saved_optim_type=None):
"""
Initialize optimizer with model parameters.
:param params:
parameters from the model
:param optim_states:
optional argument providing states of optimizer to load
:param saved_optim_type:
type of optimizer being loaded, if changed will skip loading
optimizer states
"""
opt = self.opt
# set up optimizer args
lr = opt['learningrate']
kwargs = {'lr': lr}
if opt.get('weight_decay'):
kwargs['weight_decay'] = opt['weight_decay']
if opt.get('momentum') > 0 and opt['optimizer'] in ['sgd', 'rmsprop', 'qhm']:
# turn on momentum for optimizers that use it
kwargs['momentum'] = opt['momentum']
if opt['optimizer'] == 'sgd' and opt.get('nesterov', True):
# for sgd, maybe nesterov
kwargs['nesterov'] = opt.get('nesterov', True)
elif opt['optimizer'] == 'qhm':
# qhm needs a nu
kwargs['nu'] = opt.get('nus', (0.7,))[0]
elif opt['optimizer'] == 'adam':
# turn on amsgrad for adam
# amsgrad paper: https://openreview.net/forum?id=ryQu7f-RZ
kwargs['amsgrad'] = True
if self.fp16 and self.fp16_impl == 'mem_efficient':
# grab this implementation instead
opt['optimizer'] = 'mem_eff_adam'
elif opt['optimizer'] == 'qhadam':
# set nus for qhadam
kwargs['nus'] = opt.get('nus', (0.7, 1.0))
elif opt['optimizer'] == 'adafactor':
# adafactor params
kwargs['beta1'] = opt.get('betas', (0.9, 0.999))[0]
kwargs['eps'] = opt['adafactor_eps']
kwargs['warmup_init'] = opt.get('warmup_updates', -1) > 0
if opt['optimizer'] in [
'adam',
'sparseadam',
'fused_adam',
'adamax',
'qhadam',
'fused_lamb',
]:
# set betas for optims that use it
kwargs['betas'] = opt.get('betas', (0.9, 0.999))
# set adam optimizer, but only if user specified it
if opt.get('adam_eps'):
kwargs['eps'] = opt['adam_eps']
# handle fused_adam where the user doesn't have apex installed
if saved_optim_type == 'fused_adam' and 'fused_adam' not in self.optim_opts():
# we trained with apex, but the user doesn't have apex installed.
saved_optim_type = 'adam'
if (
self.opt['optimizer'] == 'fused_adam'
and 'fused_adam' not in self.optim_opts()
):
raise ImportError(
'You are using --optimizer fused_adam, but you do not have APEX '
'installed. Please install APEX (https://github.com/NVIDIA/apex) or '
'switch to --optimizer adam.'
)
optim_class = self.optim_opts()[opt['optimizer']]
self.optimizer = optim_class(params, **kwargs)
if self.fp16:
if self.fp16_impl == 'apex':
self.optimizer = fp16_optimizer_wrapper(self.optimizer)
else:
# Using memory efficient optimizer
opt_name = opt['optimizer']
compatible_list = MemoryEfficientFP16Optimizer.compatible_optimizers()
is_compat = opt_name in compatible_list
if not is_compat:
raise RuntimeError(
f'The optimizer you selected {opt_name} is not compatible '
'with Memory Efficient FP16. Please select from among this '
f'list:\n{compatible_list}'
)
self.optimizer = MemoryEfficientFP16Optimizer(self.optimizer)
# TODO: we might want to hard reset optimizers here in the
# case of fine tuning. Some rudimentary experiments seemed to
# indicate that keeping adam weights around was desirable, so this
# will remain the behavior for the time being.
if optim_states and saved_optim_type != opt['optimizer']:
# we changed from adam to adamax, or sgd to adam, or similar
print('WARNING: not loading optim state since optim class changed.')
elif optim_states:
# check for any fp16/fp32 conversions we need to do
optimstate_fp16 = 'loss_scaler' in optim_states
if self.fp16 and optimstate_fp16:
# previously trained in fp16, now we're training in fp16.
# ideally no action needed, but APEX broke backwards
# compatibility and this is the hack around it.
optim_states['loss_scaler'] = self.optimizer.state_dict()['loss_scaler']
elif optimstate_fp16 and not self.fp16:
# old optimizer was fp16 but now we're doing fp32,
# if apex, drop the fp16 wrapper from the state_dict and just load
# the fp16 weights into the fp32 tensors
if 'optimizer_state_dict' in optim_states:
# trained with apex
optim_states = optim_states['optimizer_state_dict']
elif not optimstate_fp16 and self.fp16:
# old optimizer was fp32, but now we're doing fp16.
# this is a bit clunky, but alternatives are worse
try:
self.optimizer.optimizer.load_state_dict(optim_states)
except ValueError:
warn_once(
'WARNING: not loading optim state since model params changed.'
)
return
else:
# previously trained in fp32, loading in fp32.
# no special treatment needed.
pass
# finally, try to actually load the optimizer state
try:
self.optimizer.load_state_dict(optim_states)
except (ValueError, KeyError):
warn_once(
'WARNING: not loading optim state since model params changed.'
)
def build_lr_scheduler(self, states=None, hard_reset=False):
"""
Create the learning rate scheduler, and assign it to self.scheduler. This
scheduler will be updated upon a call to receive_metrics. May also create
self.warmup_scheduler, if appropriate.
:param state_dict states: Possible state_dict provided by model
checkpoint, for restoring LR state
:param bool hard_reset: If true, the LR scheduler should ignore the
state dictionary.
"""
if states is None:
states = {}
optimizer = self.optimizer
if self.fp16:
# lr schedulers don't work with apex, they expect the "real" optimizer
optimizer = optimizer.optimizer
self.scheduler = ParlAILRScheduler.lr_scheduler_factory(
self.opt, optimizer, states, hard_reset
)
if self.scheduler:
self._number_training_updates = (
self.scheduler.get_initial_number_training_updates()
)
def _control_local_metrics(self, enabled: bool = False, disabled: bool = False):
"""
Used to temporarily disable local metrics.
This is useful for things like when you need to call super(), but
prevent the parent from recording some metric. For example, if you're
forwarding a dummy batch or calling super() but still want to modify
the output.
You can compare this to torch.no_grad in its goal.
"""
if not (enabled ^ disabled):
raise ValueError(
'You must provide exactly one of enabled or disabled to '
'_control_local_metrics.'
)
self.__local_metrics_enabled = enabled
def record_local_metric(self, keyname: str, values: List[Metric]):
"""
Record an example-level metric for all items in the batch.
Local metrics are maybe recorded anywhere within batch act. They will
automatically be collated and returned at the end of batch_act. The
beginning of batch_act resets these, so you may not use them during
observe.
Example local metrics include ppl, token_acc, any other agent-specific
metrics.
"""
if not self.__local_metrics_enabled:
return
if keyname in self._local_metrics:
# we could relax this already
raise KeyError(f"Already recorded metrics for {keyname}")
self._local_metrics[keyname] = values
def report(self):
"""
Report metrics.
Report includes learning rate and number of training updates.
"""
report = self.global_metrics.report()
# only report LR if we have a scheduler
if hasattr(self, 'scheduler') and self.scheduler is not None:
report['lr'] = GlobalAverageMetric(self.optimizer.param_groups[0]['lr'])
if self.use_cuda:
report['gpu_mem'] = GlobalAverageMetric(self._gpu_usage())
if is_primary_worker() and self._number_training_updates:
# number train updates doesn't work in hogwild sadly, and should only
# be done on the primary worker
report['total_train_updates'] = GlobalFixedMetric(
self._number_training_updates
)
return report
def _gpu_usage(self):
"""
Compute GPU memory usage.
Includes both allocated and cached memory; this should be close to the
output of nvidia-smi, but not reflect of how much is currently demanded
by the program. It may be viewed as a rough approximation of
worst-case-until-now.
:return: Percent of allocated GPU memory as a fraction of available.
"""
if not self.use_cuda:
return None
if self.opt['gpu'] == -1:
# use all gpus available locally
devices = range(torch.cuda.device_count())
else:
devices = [self.opt['gpu']]
memory_avail = 0
memory_used = 0
for dev in devices:
props = torch.cuda.get_device_properties(dev)
memory_avail += props.total_memory
memory_used += torch.cuda.memory_allocated(dev) + torch.cuda.memory_cached(
dev
)
return memory_used / memory_avail
def receive_metrics(self, metrics_dict):
if not hasattr(self, 'scheduler') or self.scheduler is None:
return
self.scheduler.valid_step(metrics_dict)
def _get_embtype(self, emb_type):
# set up preinitialized embeddings
if emb_type.startswith('glove'):
init = 'glove'
from parlai.zoo.glove_vectors.build import download
embs = download(self.opt.get('datapath'))
elif emb_type.startswith('fasttext_cc'):
init = 'fasttext_cc'
from parlai.zoo.fasttext_cc_vectors.build import download
embs = download(self.opt.get('datapath'))
elif emb_type.startswith('fasttext'):
init = 'fasttext'
from parlai.zoo.fasttext_vectors.build import download
embs = download(self.opt.get('datapath'))
else:
raise RuntimeError(
'embedding type {} not implemented. check arg, '
'submit PR to this function, or override it.'
''.format(emb_type)
)
return embs, init
def _project_vec(self, vec, target_dim, method='random'):
"""
If needed, project vector to target dimensionality.
Projection methods implemented are the following:
random - random gaussian matrix multiplication of input vector
:param vec:
one-dimensional vector
:param target_dim:
dimension of returned vector
:param method:
projection method. will be used even if the dim is not changing if
method ends in "-force".
"""
pre_dim = vec.size(0)
if pre_dim != target_dim or method.endswith('force'):
if method.startswith('random'):
# random projection
if not hasattr(self, 'proj_rp'):
self.proj_rp = torch.Tensor(pre_dim, target_dim).normal_()
# rescale so we're not destroying norms too much
# http://scikit-learn.org/stable/modules/random_projection.html#gaussian-random-projection
self.proj_rp /= target_dim
return torch.mm(vec.unsqueeze(0), self.proj_rp)
else:
# TODO: PCA
# TODO: PCA + RP
# TODO: copy
raise RuntimeError(
'Projection method not implemented: {}' ''.format(method)
)
else:
return vec
def _copy_embeddings(self, weight, emb_type, log=True):
"""
Copy embeddings from the pretrained embeddings to the lookuptable.
:param weight:
weights of lookup table (nn.Embedding/nn.EmbeddingBag)
:param emb_type:
pretrained embedding type
"""
if self.opt['embedding_type'] == 'random':
# Random embedding means no copying of pretrained embeddings
return
embs, name = self._get_embtype(emb_type)
cnt = 0
for w, i in self.dict.tok2ind.items():
if w in embs.stoi:
vec = self._project_vec(embs.vectors[embs.stoi[w]], weight.size(1))
weight.data[i] = vec
cnt += 1
if log:
print(
'Initialized embeddings for {} tokens ({}%) from {}.'
''.format(cnt, round(cnt * 100 / len(self.dict), 1), name)
)
def share(self):
"""
Share fields from parent as well as useful objects in this class.
Subclasses will likely want to share their model as well.
"""
shared = super().share()
if self.opt.get('numthreads', 1) > 1 and isinstance(self.metrics, dict):
# move metrics and model to shared memory
self.metrics = SharedTable(self.metrics)
self.model.share_memory()
shared['metrics'] = self.metrics
shared['global_metrics'] = self.global_metrics.share()
shared['dict'] = self.dict
shared['model'] = self.model
shared['criterion'] = self.criterion
shared['opt'] = self.opt
return shared
def _add_start_end_tokens(self, vec, add_start=False, add_end=False):
"""
Add start and end tokens to a list or tensor.
"""
if isinstance(vec, torch.Tensor):
if len(vec.shape) != 1:
raise Exception('_add_start_end_tokens expects a 1D tensor')
tensors = [vec]
if add_start:
tensors.insert(0, vec.new_tensor([self.START_IDX]))
if add_end:
tensors.append(vec.new_tensor([self.END_IDX]))
return torch.cat(tensors, 0)
if add_start:
vec.insert(0, self.START_IDX)
if add_end:
vec.append(self.END_IDX)
return vec
def _v2t(self, vec):
"""
Convert token indices to string of tokens.
"""
new_vec = []
if hasattr(vec, 'cpu'):
vec = vec.cpu()
for i in vec:
if i == self.END_IDX:
break
new_vec.append(i)
return self.dict.vec2txt(new_vec)
def _vectorize_text(
self, text, add_start=False, add_end=False, truncate=None, truncate_left=True
):
"""
Return vector from text.
:param text:
String to vectorize.
:param add_start:
Add the start token to the front of the tensor.
:param add_end:
Add the end token to the end of the tensor.
:param truncate:
Truncate to this many tokens >= 0, or None.
:param truncate_left:
Truncate from the left side (keep the rightmost tokens). You
probably want this True for inputs, False for targets.
"""
vec = self.dict.txt2vec(text)
vec = self._add_start_end_tokens(vec, add_start, add_end)
vec = self._check_truncate(vec, truncate, truncate_left)
tensor = torch.LongTensor(vec)
return tensor
def _check_truncate(self, vec, truncate, truncate_left=False):
"""
Check that vector is truncated correctly.
"""
if truncate is None:
return vec
if len(vec) <= truncate:
return vec
if truncate_left:
return vec[-truncate:]
else:
return vec[:truncate]
def _set_text_vec(self, obs, history, truncate):
"""
Set the 'text_vec' field in the observation.
Useful to override to change vectorization behavior
"""
if 'text' not in obs:
return obs
if 'text_vec' not in obs:
# text vec is not precomputed, so we set it using the history
history_string = history.get_history_str()
# when text not exist, we get text_vec from history string
# history could be none if it is an image task and 'text'
# filed is be empty. We don't want this
if history_string is None:
return obs
obs['full_text'] = history_string
if history_string:
obs['text_vec'] = history.get_history_vec()
# check truncation
if obs.get('text_vec') is not None:
truncated_vec = self._check_truncate(obs['text_vec'], truncate, True)
obs.force_set('text_vec', torch.LongTensor(truncated_vec))
return obs
def _set_label_vec(self, obs, add_start, add_end, truncate):
"""
Set the 'labels_vec' field in the observation.
Useful to override to change vectorization behavior
"""
# convert 'labels' or 'eval_labels' into vectors
if 'labels' in obs:
label_type = 'labels'
elif 'eval_labels' in obs:
label_type = 'eval_labels'
else:
label_type = None
if label_type is None:
return
elif label_type + '_vec' in obs:
# check truncation of pre-computed vector
truncated_vec = self._check_truncate(obs[label_type + '_vec'], truncate)
obs.force_set(label_type + '_vec', torch.LongTensor(truncated_vec))
else:
# pick one label if there are multiple
lbls = obs[label_type]
label = lbls[0] if len(lbls) == 1 else self.random.choice(lbls)
vec_label = self._vectorize_text(label, add_start, add_end, truncate, False)
obs[label_type + '_vec'] = vec_label
obs[label_type + '_choice'] = label
return obs
def _set_label_cands_vec(self, obs, add_start, add_end, truncate):
"""
Set the 'label_candidates_vec' field in the observation.
Useful to override to change vectorization behavior
"""
if 'label_candidates_vecs' in obs:
if truncate is not None:
# check truncation of pre-computed vectors
vecs = obs['label_candidates_vecs']
for i, c in enumerate(vecs):
vecs[i] = self._check_truncate(c, truncate)
elif self.rank_candidates and obs.get('label_candidates'):
obs.force_set('label_candidates', list(obs['label_candidates']))
obs['label_candidates_vecs'] = [
self._vectorize_text(c, add_start, add_end, truncate, False)
for c in obs['label_candidates']
]
return obs
def vectorize(
self,
obs,
history,
add_start=True,
add_end=True,
text_truncate=None,
label_truncate=None,
):
"""
Make vectors out of observation fields and store in the observation.
In particular, the 'text' and 'labels'/'eval_labels' fields are
processed and a new field is added to the observation with the suffix
'_vec'.
If you want to use additional fields on your subclass, you can override
this function, call super().vectorize(...) to process the text and
labels, and then process the other fields in your subclass.
Additionally, if you want to override some of these default parameters,
then we recommend using a pattern like:
.. code-block:: python
def vectorize(self, *args, **kwargs):
kwargs['add_start'] = False
return super().vectorize(*args, **kwargs)
:param obs:
Single observation from observe function.
:param add_start:
default True, adds the start token to each label.
:param add_end:
default True, adds the end token to each label.
:param text_truncate:
default None, if set truncates text vectors to the specified
length.
:param label_truncate:
default None, if set truncates label vectors to the specified
length.
:return:
the input observation, with 'text_vec', 'label_vec', and
'cands_vec' fields added.
"""
self._set_text_vec(obs, history, text_truncate)
self._set_label_vec(obs, add_start, add_end, label_truncate)
self._set_label_cands_vec(obs, add_start, add_end, label_truncate)
return obs
def _pad_tensor(
self, items: List[Union[List[int], torch.LongTensor]]
) -> Tuple[torch.LongTensor, List[int]]:
"""
Create a right padded matrix from an uneven list of lists.
Returns (padded, lengths), where padded is the padded matrix, and lengths
is a list containing the lengths of each row.
:param list[iter[int]] items: List of items
:returns: (padded, lengths) tuple
:rtype: (Tensor[int64], list[int])
This is intentionally overridable so that models can control how
to pad their input.
"""
return padded_tensor(
items,
pad_idx=self.NULL_IDX,
use_cuda=self.use_cuda,
fp16friendly=self.fp16,
device=self.opt['gpu'],
)
def is_valid(self, obs):
"""
Determine if an observation is valid or not.
"""
return 'text_vec' in obs or 'image' in obs
def batchify(self, obs_batch, sort=False):
"""
Create a batch of valid observations from an unchecked batch.
A valid observation is one that passes the lambda provided to the
function, which defaults to checking if the preprocessed 'text_vec'
field is present which would have been set by this agent's 'vectorize'
function.
Returns a namedtuple Batch. See original definition above for in-depth
explanation of each field.
If you want to include additonal fields in the batch, you can subclass
this function and return your own "Batch" namedtuple: copy the Batch
namedtuple at the top of this class, and then add whatever additional
fields that you want to be able to access. You can then call
super().batchify(...) to set up the original fields and then set up the
additional fields in your subclass and return that batch instead.
:param obs_batch:
List of vectorized observations
:param sort:
Default False, orders the observations by length of vectors. Set to
true when using torch.nn.utils.rnn.pack_padded_sequence. Uses the text
vectors if available, otherwise uses the label vectors if available.
"""
if len(obs_batch) == 0:
return Batch()
valid_obs = [(i, ex) for i, ex in enumerate(obs_batch) if self.is_valid(ex)]
if len(valid_obs) == 0:
return Batch()
valid_inds, exs = zip(*valid_obs)
# TEXT
xs, x_lens = None, None
if any(ex.get('text_vec') is not None for ex in exs):
_xs = [ex.get('text_vec', self.EMPTY) for ex in exs]
xs, x_lens = self._pad_tensor(_xs)
if sort:
sort = False # now we won't sort on labels
xs, x_lens, valid_inds, exs = argsort(
x_lens, xs, x_lens, valid_inds, exs, descending=True
)
# LABELS
labels_avail = any('labels_vec' in ex for ex in exs)
some_labels_avail = labels_avail or any('eval_labels_vec' in ex for ex in exs)
ys, y_lens, labels = None, None, None
if some_labels_avail:
field = 'labels' if labels_avail else 'eval_labels'
label_vecs = [ex.get(field + '_vec', self.EMPTY) for ex in exs]
labels = [ex.get(field + '_choice') for ex in exs]
y_lens = [y.shape[0] for y in label_vecs]
ys, y_lens = self._pad_tensor(label_vecs)
if sort and xs is None:
ys, valid_inds, label_vecs, labels, y_lens = argsort(
y_lens, ys, valid_inds, label_vecs, labels, y_lens, descending=True
)
# LABEL_CANDIDATES
cands, cand_vecs = None, None
if any('label_candidates_vecs' in ex for ex in exs):
cands = [ex.get('label_candidates', None) for ex in exs]
cand_vecs = [ex.get('label_candidates_vecs', None) for ex in exs]
# IMAGE
imgs = None
if any('image' in ex for ex in exs):
imgs = [ex.get('image', None) for ex in exs]
return Batch(
text_vec=xs,
text_lengths=x_lens,
label_vec=ys,
label_lengths=y_lens,
labels=labels,
valid_indices=valid_inds,
candidates=cands,
candidate_vecs=cand_vecs,
image=imgs,
observations=exs,
)
def match_batch(self, batch_reply, valid_inds, output=None):
"""
Match sub-batch of predictions to the original batch indices.
Batches may be only partially filled (i.e when completing the remainder
at the end of the validation or test set), or we may want to sort by
e.g the length of the input sequences if using pack_padded_sequence.
This matches rows back with their original row in the batch for
calculating metrics like accuracy.
If output is None (model choosing not to provide any predictions), we
will just return the batch of replies.
Otherwise, output should be a parlai.core.torch_agent.Output object.
This is a namedtuple, which can provide text predictions and/or
text_candidates predictions. If you would like to map additional
fields into the batch_reply, you can override this method as well as
providing your own namedtuple with additional fields.
:param batch_reply:
Full-batchsize list of message dictionaries to put responses into.
:param valid_inds:
Original indices of the predictions.
:param output:
Output namedtuple which contains sub-batchsize list of text outputs
from model. May be None (default) if model chooses not to answer.
This method will check for ``text`` and ``text_candidates`` fields.
"""
if output is None:
return batch_reply
for k, v in output.items():
if v is None:
continue
for i, sub_val in zip(valid_inds, v):
batch_reply[i][k] = sub_val
return batch_reply
def observe(self, observation):
"""
Process incoming message in preparation for producing a response.
This includes remembering the past history of the conversation.
"""
# TODO: Migration plan: TorchAgent currently supports being passed
# observations as vanilla dicts for legacy interop; eventually we
# want to remove this behavior and demand that teachers return Messages
observation = Message(observation)
# Sanity check everything is in order
self._validate_observe_invariants()
if observation.get('episode_done'):
self.__expecting_clear_history = True
elif 'labels' in observation or 'eval_labels' in observation:
# make sure we note that we're expecting a reply in the future
self.__expecting_to_reply = True
self.observation = observation
# update the history using the observation
self.history.update_history(observation)
return self.vectorize(
observation,
self.history,
text_truncate=self.text_truncate,
label_truncate=self.label_truncate,
)
def self_observe(self, self_message: Message) -> None:
"""
Observe one's own utterance.
This is used so that the agent can incorporate its own response into
the dialogue history after a batch_act. Failure to implement this will
result in an agent that cannot hear itself speak.
:param self_message:
The message corresponding to the output from batch_act.
"""
use_reply = self.opt.get('use_reply', 'label')
# quick check everything is in order
self._validate_self_observe_invariants()
assert self.observation is not None
if self.observation['episode_done']:
# oh this was the last example in the episode. reset the history
self.history.reset()
# additionally mark the last observation as invalid
self.observation = None
# and clear the safety check
self.__expecting_clear_history = False
return
# We did reply! Safety check is good next round.
self.__expecting_to_reply = False
# actually ingest the label
if use_reply == 'none':
# we're not including our own responses anyway.
return
elif use_reply == 'label':
# first look for the true label
label_key = (
'labels'
if 'labels' in self.observation
else 'eval_labels'
if 'eval_labels' in self.observation
else None
)
if label_key is not None:
lbls = self.observation[label_key]
last_reply = lbls[0] if len(lbls) == 1 else self.random.choice(lbls)
self.history.add_reply(last_reply)
return
# you might expect a hard failure here, but in interactive mode we'll
# never get a label
# otherwise, we use the last output the model generated
if self_message is not None:
last_reply = self_message['text']
self.history.add_reply(last_reply)
return
raise RuntimeError("Unexpected case in self_observe.")
def _validate_observe_invariants(self):
"""
Check that we properly called self_observe after the last batch_act.
"""
if self.__expecting_to_reply:
raise RuntimeError(
"Last observe() had a label, but no call to self_observe ever "
"happened. You are likely making multiple observe() calls without "
"a corresponding act(). This was changed in #2043. File a GitHub "
"issue if you require assistance."
)
if self.__expecting_clear_history:
raise RuntimeError(
"Last observe() was episode_done, but we never saw a corresponding "
"self_observe to clear the history, probably because you missed an "
"act(). This was changed in #2043. File a GitHub issue if you require "
"assistance."
)
def _validate_self_observe_invariants(self):
"""
Check some invariant conditions for self_observe.
Goal is to catch potential places where we forget to call self_observe.
"""
if self.observation is None:
raise RuntimeError(
"You're self_observing without having observed something. Check if "
"you're missing a step in your observe/act/self_observe loop."
)
if self.observation['episode_done']:
if not self.__expecting_clear_history:
raise RuntimeError(
"You probably overrode observe() without implementing calling "
"super().observe(). This is unexpected. *If you must* avoid the "
"super call, then you should file a GitHub issue referencing "
"#2043."
)
def state_dict(self):
"""
Get the state dict for saving.
Override this method for more specific saving.
"""
states = {}
if hasattr(self, 'model'): # save model params
if hasattr(self.model, 'module'):
# did we wrap in a DistributedDataParallel
states['model'] = self.model.module.state_dict()
else:
states['model'] = self.model.state_dict()
if hasattr(self, 'optimizer'):
# save optimizer params
states['optimizer'] = self.optimizer.state_dict()
states['optimizer_type'] = self.opt['optimizer']
# lr scheduler
if torch.__version__.startswith('0.'):
warn_once(
"Must upgrade to Pytorch 1.0 to save the state of your " "LR scheduler."
)
else:
states['number_training_updates'] = self._number_training_updates
if getattr(self, 'scheduler', None):
states['lr_scheduler'] = self.scheduler.get_state_dict()
states['lr_scheduler_type'] = self.opt['lr_scheduler']
states['warmup_scheduler'] = self.scheduler.get_warmup_state_dict()
return states
def save(self, path=None):
"""
Save model parameters to path (or default to model_file arg).
Please try to refrain from overriding this function, and instead override
`state_dict(self)` for more specific saving.
"""
path = self.opt.get('model_file', None) if path is None else path
if path:
model_dict_path = path + '.dict'
if hasattr(self, 'dict') and not os.path.exists(
model_dict_path
): # force save dictionary
# TODO: Look into possibly overriding opt('dict_file') with new path
self.dict.save(model_dict_path, sort=False)
states = self.state_dict()
if states: # anything found to save?
with open(path, 'wb') as write:
torch.save(states, write)
# save opt file
with open(path + '.opt', 'w', encoding='utf-8') as handle:
if hasattr(self, 'model_version'):
self.opt['model_version'] = self.model_version()
saved_opts = deepcopy(self.opt)
if 'interactive_mode' in saved_opts:
# We do not save the state of interactive mode, it is only decided
# by scripts or command line.
del saved_opts['interactive_mode']
json.dump(saved_opts, handle, indent=4)
# for convenience of working with jq, make sure there's a newline
handle.write('\n')
def load_state_dict(self, state_dict):
"""
Load the state dict into model.
This is easily overridable to facilitate transfer of state dicts.
"""
try:
self.model.load_state_dict(state_dict)
except RuntimeError as msg:
msg_ = str(msg)
if 'size mismatch' in msg_ and 'embedding' in msg_:
raise RuntimeError(
f'{msg_}\n'
'-----------------\n'
'Could not load the model due to a size mismatch in the '
'embeddings. A common reason for this is trying to load '
'a model trained with fp16 but loaded without fp16. Try '
'adding --fp16 true or --force-fp16-tokens true.'
)
else:
raise
def load(self, path: str) -> Dict[str, Any]:
"""
Return opt and model states.
Override this method for more specific loading.
"""
import parlai.utils.pickle
states = torch.load(
path, map_location=lambda cpu, _: cpu, pickle_module=parlai.utils.pickle
)
if 'model' in states:
self.load_state_dict(states['model'])
if 'optimizer' in states and hasattr(self, 'optimizer'):
self.optimizer.load_state_dict(states['optimizer'])
return states
@classmethod
def upgrade_opt(cls, opt_from_disk: Opt):
# call the parent upgrades
opt_from_disk = super(TorchAgent, cls).upgrade_opt(opt_from_disk)
if opt_from_disk.get('fp16'):
# 2020-01-28 If the model was trained with fp16, we might not have saved
# the dict with the special fp16 tokens (https://git.io/Jvm7N), IF the
# dict was built the same time as the model. We set this to tell the
# model it MUST add the fp16 tokens, even if it's not fp16 mode now.
opt_from_disk['force_fp16_tokens'] = True
return opt_from_disk
def reset(self):
"""
Clear internal states.
"""
# assumption violation trackers
self.__expecting_clear_history = False
self.__expecting_to_reply = False
self.observation = None
self.history.reset()
self.reset_metrics()
def reset_metrics(self):
"""
Reset all TorchAgentMetrics.
"""
super().reset_metrics()
self.global_metrics.clear()
def act(self):
"""
Call batch_act with the singleton batch.
"""
# BatchWorld handles calling self_observe, but we're in a Hogwild or Interactive
# world, so we need to handle this ourselves.
response = self.batch_act([self.observation])[0]
self.self_observe(response)
return response
def batch_act(self, observations):
"""
Process a batch of observations (batchsize list of message dicts).
These observations have been preprocessed by the observe method.
Subclasses can override this for special functionality, but if the
default behaviors are fine then just override the ``train_step`` and
``eval_step`` methods instead. The former is called when labels are
present in the observations batch; otherwise, the latter is called.
"""
# clear local metrics before anything else
self._local_metrics.clear()
# initialize a list of replies with this agent's id
batch_reply = [
Message({'id': self.getID(), 'episode_done': False}) for _ in observations
]
# check if there are any labels available, if so we will train on them
self.is_training = any('labels' in obs for obs in observations)
# create a batch from the vectors
batch = self.batchify(observations)
if (
'label_vec' in batch
and 'text_vec' in batch
and batch.label_vec is not None
and batch.text_vec is not None
):
# tokens per batch
# we divide by the binary is_primary_worker() so that the numerator is
# num_tokens in all workers, and the denominator is 1.
tpb = GlobalAverageMetric(
(batch.label_vec != self.NULL_IDX).sum().item(),
float(is_primary_worker()),
)
self.global_metrics.add('tpb', tpb)
if self.is_training:
output = self.train_step(batch)
else:
with torch.no_grad():
# save memory and compute by disabling autograd.
# use `with torch.enable_grad()` to gain back gradients.
output = self.eval_step(batch)
if output is not None:
# local metrics are automatically matched up
self.match_batch(batch_reply, batch.valid_indices, output)
# broadcast the metrics back
for k, values in self._local_metrics.items():
if len(values) != len(batch.valid_indices):
raise IndexError(
f"Batchsize mismatch on metric {k} (got {len(values)}, "
f"expected {len(batch.valid_indices)}"
)
for i, value in zip(batch.valid_indices, values):
if 'metrics' not in batch_reply[i]:
batch_reply[i]['metrics'] = {}
batch_reply[i]['metrics'][k] = value
# Make sure we push all the metrics to main thread in hogwild/workers
self.global_metrics.flush()
return batch_reply
@abstractmethod
def train_step(self, batch):
"""
[Abstract] Process one batch with training labels.
"""
pass
@abstractmethod
def eval_step(self, batch):
"""
[Abstract] Process one batch but do not train on it.
"""
pass
def set_interactive_mode(self, mode, shared):
"""
Set interactive mode on or off.
"""
if shared is None and mode:
# Only print in the non-shared version.
print("[" + self.id + ': full interactive mode on.' + ']')
def backward(self, loss):
"""
Perform a backward pass.
It is recommended you use this instead of loss.backward(), for integration with
distributed training and FP16 training.
"""
update_freq = self.opt.get('update_freq', 1)
if update_freq > 1:
# gradient accumulation, but still need to average across the minibatches
loss = loss / update_freq
self._number_grad_accum = (self._number_grad_accum + 1) % update_freq
# we're doing gradient accumulation, so we don't need to sync gradients
# amoung GPUs
if self._number_grad_accum != 0 and is_distributed():
# accumulate without syncing
with self.model.no_sync():
if self.fp16:
self.optimizer.backward(loss, update_master_grads=False)
else:
loss.backward()
return
if self.fp16:
self.optimizer.backward(loss, update_master_grads=False)
else:
loss.backward()
def update_params(self):
"""
Perform step of optimization.
Handles clipping gradients and adjusting LR schedule if needed.
Gradient accumulation is also performed if agent is called with
--update-freq.
It is recommended (but not forced) that you call this in train_step.
"""
update_freq = self.opt.get('update_freq', 1)
if update_freq > 1:
# we're doing gradient accumulation, so we don't only want to step
# every N updates instead
# self._number_grad_accum is updated in backward function
if self._number_grad_accum != 0:
return
if self.fp16:
# we've been accumulating grads in fp16 and delaying the fp32 copy update.
# finally time to perform the update.
self.optimizer.update_master_grads()
if self.opt.get('gradient_clip', -1) > 0:
if self.fp16:
grad_norm = self.optimizer.clip_master_grads(self.opt['gradient_clip'])
else:
grad_norm = torch.nn.utils.clip_grad_norm_(
self.model.parameters(), self.opt['gradient_clip']
)
self.global_metrics.add('gnorm', GlobalAverageMetric(grad_norm))
self.global_metrics.add(
'clip',
GlobalAverageMetric(float(grad_norm > self.opt['gradient_clip'])),
)
else:
parameters = self.model.parameters()
grad_norm = compute_grad_norm(parameters)
self.global_metrics.add('gnorm', GlobalAverageMetric(grad_norm))
if self.fp16:
self.global_metrics.add(
'fp16_loss_scalar', GlobalAverageMetric(self.optimizer.loss_scale)
)
self.optimizer.step()
# keep track up number of steps, compute warmup factor
self._number_training_updates += 1
# in distributed mode, all workers step together, but we need to only
# count it once. Only the primary worker gets to make the count
if is_primary_worker():
self.global_metrics.add('updates', GlobalSumMetric(1))
if getattr(self, 'scheduler', None):
self.scheduler.step(self._number_training_updates)
def zero_grad(self):
"""
Zero out optimizer.
It is recommended you call this in train_step. It automatically handles gradient
accumulation if agent is called with --update-freq.
"""
if self._number_grad_accum != 0:
# if we're accumulating gradients, don't actually zero things out yet.
return
self.optimizer.zero_grad()
|
py | 7dff2e90c3aa9d03bd8e00c8143c352535ab79be | from flask import Flask, request, json, abort, render_template
from redis import StrictRedis
app = Flask(__name__, static_url_path='')
redis = StrictRedis(host='localhost', port=6379, db=0)
@app.route('/', methods=['GET'])
def index():
return render_template('index.html')
@app.route('/views/<log>', methods=['GET'])
def get_log_page(log):
# try:
if check_log_name(log):
if redis.keys(log):
data, last_entry = format_log_data(log)
entry_count = redis.llen(log)
return render_template('view.html', data=data, entry_count=entry_count, last_entry=last_entry, log_name=log)
else:
return abort(404)
else:
return abort(400)
# except Exception as e:
# return abort(500)
@app.route('/logs/<log>', methods=['GET'])
def get_log_data(log):
return log
@app.route('/logs/<log>/config', methods=['GET'])
def get_log_config(log):
# try:
if check_log_name(log):
if redis.keys(log):
data, last_entry = format_log_data(log)
entry_count = redis.llen(log)
return render_template('view.html', data=data, entry_count=entry_count, last_entry=last_entry, log_name=log)
else:
return abort(404)
else:
return abort(400)
# except Exception as e:
# return abort(500)
@app.route('/logs/<log>', methods=['PUT'])
def add_log_data(log):
if check_log_name(log) is not True or check_log_data(request.json['data']) is not True:
return abort(400)
else:
try:
redis.lpush(log, json.dumps({'datetime': request.json['datetime'], 'data': request.json['data']}))
return ""
except Exception as e:
pass
@app.route('/logs', methods=['POST'])
def create_log():
try:
log_id = redis.incr('log_id')
redis.hmset('log', {'id': log_id})
response = app.response_class(response=json.dumps({'id': str(log_id)}), status=200, mimetype='application/json')
return response
except Exception as e:
return str(e)
@app.route('/logs/<log>', methods=['DELETE'])
def delete_log(log):
try:
redis.delete(log)
return ''
except Exception as e:
print(e)
pass
def check_log_name(name):
if len(name) <= 0:
return False
else:
return True
def check_log_data(data):
if not isinstance(data, float):
return False
else:
return True
def format_log_data(log):
data = redis.lrange(log, 0, -1)
dict = {}
x = []
y = []
last_entry = json.loads(data[-1])['datetime']
for entry in data:
entry = json.loads(entry)
x.append(entry['datetime'])
y.append(entry['data'])
dict['x'] = x
dict['y'] = y
dict['type'] = 'scatter'
return [dict], last_entry
if __name__ == '__main__':
app.run(debug=True)
|
py | 7dff2f061b676e49f4ca37cfde307685e5241744 | from ctypes import *
import math
import random
def sample(probs):
s = sum(probs)
probs = [a/s for a in probs]
r = random.uniform(0, 1)
for i in range(len(probs)):
r = r - probs[i]
if r <= 0:
return i
return len(probs)-1
def c_array(ctype, values):
return (ctype * len(values))(*values)
class IMAGE(Structure):
_fields_ = [("w", c_int),
("h", c_int),
("c", c_int),
("data", POINTER(c_float))]
class METADATA(Structure):
_fields_ = [("classes", c_int),
("names", POINTER(c_char_p))]
#lib = CDLL("/home/pjreddie/documents/darknet/libdarknet.so", RTLD_GLOBAL)
lib = CDLL("libdarknet.so", RTLD_GLOBAL)
lib.network_width.argtypes = [c_void_p]
lib.network_width.restype = c_int
lib.network_height.argtypes = [c_void_p]
lib.network_height.restype = c_int
predict = lib.network_predict_p
predict.argtypes = [c_void_p, POINTER(c_float)]
predict.restype = POINTER(c_float)
reset_rnn = lib.reset_rnn
reset_rnn.argtypes = [c_void_p]
load_net = lib.load_network_p
load_net.argtypes = [c_char_p, c_char_p, c_int]
load_net.restype = c_void_p
letterbox_image = lib.letterbox_image
letterbox_image.argtypes = [IMAGE, c_int, c_int]
letterbox_image.restype = IMAGE
load_meta = lib.get_metadata
lib.get_metadata.argtypes = [c_char_p]
lib.get_metadata.restype = METADATA
load_image = lib.load_image_color
load_image.argtypes = [c_char_p, c_int, c_int]
load_image.restype = IMAGE
predict_image = lib.network_predict_image
predict_image.argtypes = [c_void_p, IMAGE]
predict_image.restype = POINTER(c_float)
def classify(net, meta, im):
out = predict_image(net, im)
res = []
for i in range(meta.classes):
res.append((meta.names[i], out[i]))
res = sorted(res, key=lambda x: -x[1])
return res
def detect(net, meta, im):
out = predict_image(net, im)
res = []
for i in range(meta.classes):
res.append((meta.names[i], out[i]))
res = sorted(res, key=lambda x: -x[1])
return res
if __name__ == "__main__":
net = load_net("cfg/densenet201.cfg", "/home/pjreddie/trained/densenet201.weights", 0)
im = load_image("data/wolf.jpg", 0, 0)
meta = load_meta("cfg/imagenet1k.data")
r = classify(net, meta, im)
print r[:10]
|
py | 7dff2f0b7863b3235f10fd051b4de3f9249984b1 | #!/usr/bin/python
from sfa.rspecs.pg_rspec_converter import PGRSpecConverter
from sfa.rspecs.sfa_rspec_converter import SfaRSpecConverter
from sfa.rspecs.rspec import RSpec
from sfa.rspecs.version_manager import VersionManager
class RSpecConverter:
@staticmethod
def to_sfa_rspec(in_rspec, content_type=None):
rspec = RSpec(in_rspec)
version_manager = VersionManager()
sfa_version = version_manager._get_version('sfa', '1')
pg_version = version_manager._get_version('protogeni', '2')
if rspec.version.type.lower() == sfa_version.type.lower():
return in_rspec
elif rspec.version.type.lower() == pg_version.type.lower():
return PGRSpecConverter.to_sfa_rspec(in_rspec, content_type)
else:
return in_rspec
@staticmethod
def to_pg_rspec(in_rspec, content_type=None):
rspec = RSpec(in_rspec)
version_manager = VersionManager()
sfa_version = version_manager._get_version('sfa', '1')
pg_version = version_manager._get_version('protogeni', '2')
if rspec.version.type.lower() == pg_version.type.lower():
return in_rspec
elif rspec.version.type.lower() == sfa_version.type.lower():
return SfaRSpecConverter.to_pg_rspec(in_rspec, content_type)
else:
return in_rspec
if __name__ == '__main__':
pg_rspec = 'test/protogeni.rspec'
sfa_rspec = 'test/nodes.rspec'
print "converting pg rspec to sfa rspec"
print RSpecConverter.to_sfa_rspec(pg_rspec)
print "converting sfa rspec to pg rspec"
print RSpecConverter.to_pg_rspec(sfa_rspec)
|
py | 7dff2f7fdf467b985d2e33aae86b5903d0ea48ce | # Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
from collections import deque
class Solution:
def rightSideView(self, root: TreeNode) -> List[int]:
if not root:
return []
queue=deque()
queue.append(root)
res=[]
while(queue):
size=len(queue)
for i in range(size):
currNode=queue.popleft()
if i==size-1:
res.append(currNode.val)
if currNode.left:
queue.append(currNode.left)
if currNode.right:
queue.append(currNode.right)
return res
|
py | 7dff2ffa492de807c9672a08ee4ef94b7cdc2ffd | #
# PySNMP MIB module DNSSERVEREXT-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/DNSSERVEREXT-MIB
# Produced by pysmi-0.3.4 at Wed May 1 12:52:24 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
dnsServerExt, = mibBuilder.importSymbols("APENT-MIB", "dnsServerExt")
Integer, ObjectIdentifier, OctetString = mibBuilder.importSymbols("ASN1", "Integer", "ObjectIdentifier", "OctetString")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
ValueRangeConstraint, ConstraintsUnion, ValueSizeConstraint, SingleValueConstraint, ConstraintsIntersection = mibBuilder.importSymbols("ASN1-REFINEMENT", "ValueRangeConstraint", "ConstraintsUnion", "ValueSizeConstraint", "SingleValueConstraint", "ConstraintsIntersection")
ModuleCompliance, NotificationGroup = mibBuilder.importSymbols("SNMPv2-CONF", "ModuleCompliance", "NotificationGroup")
NotificationType, ObjectIdentity, ModuleIdentity, Counter64, MibIdentifier, Integer32, iso, Counter32, IpAddress, Bits, TimeTicks, Unsigned32, MibScalar, MibTable, MibTableRow, MibTableColumn, Gauge32 = mibBuilder.importSymbols("SNMPv2-SMI", "NotificationType", "ObjectIdentity", "ModuleIdentity", "Counter64", "MibIdentifier", "Integer32", "iso", "Counter32", "IpAddress", "Bits", "TimeTicks", "Unsigned32", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "Gauge32")
TextualConvention, DisplayString, RowStatus = mibBuilder.importSymbols("SNMPv2-TC", "TextualConvention", "DisplayString", "RowStatus")
apDnsServerMib = ModuleIdentity((1, 3, 6, 1, 4, 1, 2467, 1, 40, 1))
if mibBuilder.loadTexts: apDnsServerMib.setLastUpdated('9806122000Z')
if mibBuilder.loadTexts: apDnsServerMib.setOrganization('ArrowPoint Communications Inc.')
if mibBuilder.loadTexts: apDnsServerMib.setContactInfo('Postal: ArrowPoint Communications Inc. 50 Nagog Park Acton, Massachusetts 01720 Tel: +1 978-206-3000 option 1 E-Mail: [email protected]')
if mibBuilder.loadTexts: apDnsServerMib.setDescription('This MIB module describes the ArrowPoint enterprise MIB support for DNS Server')
apDnsServerEnable = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 2), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1))).clone(namedValues=NamedValues(("disable", 0), ("enable", 1)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsServerEnable.setStatus('current')
if mibBuilder.loadTexts: apDnsServerEnable.setDescription('Parameter to enable or disable DNS Server functionality.')
apDnsServerBufferCount = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 3), Integer32().subtype(subtypeSpec=ValueRangeConstraint(2, 1000)).clone(10)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsServerBufferCount.setStatus('current')
if mibBuilder.loadTexts: apDnsServerBufferCount.setDescription('The number of buffers allocated for Query Responses')
apDnsServerResponderTasks = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 4), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 250)).clone(2)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsServerResponderTasks.setStatus('current')
if mibBuilder.loadTexts: apDnsServerResponderTasks.setDescription('The number of Tasks to handle DNS Responses')
apDnsPeerRcvEntries = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 5), Integer32().subtype(subtypeSpec=ValueRangeConstraint(128, 1024)).clone(128)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsPeerRcvEntries.setStatus('current')
if mibBuilder.loadTexts: apDnsPeerRcvEntries.setDescription('The number of DNS entries which can be received from a peer')
apDnsPeerSndEntries = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 6), Integer32().subtype(subtypeSpec=ValueRangeConstraint(128, 1024)).clone(128)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsPeerSndEntries.setStatus('current')
if mibBuilder.loadTexts: apDnsPeerSndEntries.setDescription('The number of DNS entries which can be sent to a peer')
apDnsPeerReportInterval = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 7), Integer32().subtype(subtypeSpec=ValueRangeConstraint(5, 120)).clone(5)).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsPeerReportInterval.setStatus('current')
if mibBuilder.loadTexts: apDnsPeerReportInterval.setDescription('The number of seconds between generation of DNS peer load reports')
apDnsAclIndex = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 8), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 99))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apDnsAclIndex.setStatus('current')
if mibBuilder.loadTexts: apDnsAclIndex.setDescription('The Acl which has been applied to DNS resolutions, zero means no Acl')
apProximityType = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 9), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(2, 3))).clone(namedValues=NamedValues(("pdns", 2), ("pdb", 3)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apProximityType.setStatus('current')
if mibBuilder.loadTexts: apProximityType.setDescription('Parameter to specify PDB or PDNS functionality.')
apProximityEnable = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 10), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1))).clone(namedValues=NamedValues(("disable", 0), ("enable", 1)))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apProximityEnable.setStatus('current')
if mibBuilder.loadTexts: apProximityEnable.setDescription('Parameter to enable or disable PDB / PDNS functionality.')
apProximityZone = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 11), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apProximityZone.setStatus('current')
if mibBuilder.loadTexts: apProximityZone.setDescription('The local proximity zone index')
apProximityDescription = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 12), DisplayString().subtype(subtypeSpec=ValueSizeConstraint(0, 20)).clone(hexValue="0")).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityDescription.setStatus('current')
if mibBuilder.loadTexts: apProximityDescription.setDescription('A name which identifies this proximity zone')
apProximityZoneMax = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 13), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(6, 16))).clone(namedValues=NamedValues(("tier1", 6), ("tier2", 16))).clone('tier1')).setMaxAccess("readwrite")
if mibBuilder.loadTexts: apProximityZoneMax.setStatus('current')
if mibBuilder.loadTexts: apProximityZoneMax.setDescription('The maximum number of proximity zones allowed')
apProximityPDBIpAddr = MibScalar((1, 3, 6, 1, 4, 1, 2467, 1, 40, 14), IpAddress()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityPDBIpAddr.setStatus('current')
if mibBuilder.loadTexts: apProximityPDBIpAddr.setDescription('The Interface IP Address of the PDB')
apProximityRecordTable = MibTable((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15), )
if mibBuilder.loadTexts: apProximityRecordTable.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordTable.setDescription('A list of Proximity domain name records.')
apProximityRecordEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1), ).setIndexNames((0, "DNSSERVEREXT-MIB", "apProximityRecordName"))
if mibBuilder.loadTexts: apProximityRecordEntry.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordEntry.setDescription('Proximity domain name record information.')
apProximityRecordName = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 1), DisplayString().subtype(subtypeSpec=ValueSizeConstraint(1, 31))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordName.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordName.setDescription('The dns name for this Proximity record.')
apProximityRecordType = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 2), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2))).clone(namedValues=NamedValues(("typeA", 1), ("typeNS", 2)))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordType.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordType.setDescription('Determines if this record is of type NS or A.')
apProximityRecordAddr = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 3), IpAddress()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordAddr.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordAddr.setDescription('The Interface IP Address of Peer')
apProximityRecordTtl = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 4), Integer32()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordTtl.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordTtl.setDescription('The Time to Live Value returned in DNS Responses')
apProximityRecordKalType = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 5), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1, 2))).clone(namedValues=NamedValues(("kal-none", 0), ("kal-icmp", 1), ("kal-ap", 2))).clone('kal-icmp')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordKalType.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordKalType.setDescription('The type of keepalive performed on this record')
apProximityRecordKalAddr = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 6), IpAddress()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordKalAddr.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordKalAddr.setDescription('The IP Address of interface to send AP keepalive messages')
apProximityRecordKalThreshold = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 7), Integer32().subtype(subtypeSpec=ValueRangeConstraint(2, 254)).clone(254)).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordKalThreshold.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordKalThreshold.setDescription('The record is considered DOWN when the load number is greater than this value.')
apProximityRecordRtnSingleArec = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 8), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1))).clone(namedValues=NamedValues(("multiple", 0), ("single", 1))).clone('single')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordRtnSingleArec.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordRtnSingleArec.setDescription('Determines if multiple A records will be returned in a Response for this DNS name.')
apProximityRecordStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2467, 1, 40, 15, 1, 9), RowStatus()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: apProximityRecordStatus.setStatus('current')
if mibBuilder.loadTexts: apProximityRecordStatus.setDescription('Status entry for this row ')
mibBuilder.exportSymbols("DNSSERVEREXT-MIB", apDnsServerBufferCount=apDnsServerBufferCount, apProximityRecordTtl=apProximityRecordTtl, apProximityRecordEntry=apProximityRecordEntry, apProximityRecordKalThreshold=apProximityRecordKalThreshold, apProximityRecordStatus=apProximityRecordStatus, apProximityRecordType=apProximityRecordType, apDnsAclIndex=apDnsAclIndex, apDnsPeerRcvEntries=apDnsPeerRcvEntries, apDnsServerMib=apDnsServerMib, apProximityRecordRtnSingleArec=apProximityRecordRtnSingleArec, apDnsPeerSndEntries=apDnsPeerSndEntries, apProximityRecordKalType=apProximityRecordKalType, apProximityDescription=apProximityDescription, apProximityRecordKalAddr=apProximityRecordKalAddr, apProximityRecordTable=apProximityRecordTable, apProximityEnable=apProximityEnable, apDnsServerResponderTasks=apDnsServerResponderTasks, PYSNMP_MODULE_ID=apDnsServerMib, apProximityZoneMax=apProximityZoneMax, apProximityRecordName=apProximityRecordName, apDnsPeerReportInterval=apDnsPeerReportInterval, apProximityZone=apProximityZone, apProximityType=apProximityType, apProximityPDBIpAddr=apProximityPDBIpAddr, apProximityRecordAddr=apProximityRecordAddr, apDnsServerEnable=apDnsServerEnable)
|
py | 7dff301e816c0cca25a2acedb62b2156d396c156 | # This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
r"""
Channel event manager for pulse schedules.
This module provides a `ChannelEvents` class that manages a series of instructions for a
pulse channel. Channel-wise filtering of the pulse program makes
the arrangement of channels easier in the core drawer function.
The `ChannelEvents` class is expected to be called by other programs (not by end-users).
The `ChannelEvents` class instance is created with the class method ``load_program``:
```python
event = ChannelEvents.load_program(sched, DriveChannel(0))
```
The `ChannelEvents` is created for a specific pulse channel and loosely assorts pulse
instructions within the channel with different visualization purposes.
Phase and frequency related instructions are loosely grouped as frame changes.
The instantaneous value of those operands are combined and provided as ``PhaseFreqTuple``.
Instructions that have finite duration are grouped as waveforms.
The grouped instructions are returned as an iterator by the corresponding method call:
```python
for t0, frame, instruction in event.get_waveforms():
...
for t0, frame_change, instructions in event.get_frame_changes():
...
```
The class method ``get_waveforms`` returns the iterator of waveform type instructions with
the ``PhaseFreqTuple`` (frame) at the time when instruction is issued.
This is because a pulse envelope of ``Waveform`` may be modulated with a
phase factor $exp(-i \omega t - \phi)$ with frequency $\omega$ and phase $\phi$ and
appear on the canvas. Thus, it is better to tell users in which phase and frequency
the pulse envelope is modulated from a viewpoint of program debugging.
On the other hand, the class method ``get_frame_changes`` returns a ``PhaseFreqTuple`` that
represents a total amount of change at that time because it is convenient to know
the operand value itself when we debug a program.
Because frame change type instructions are usually zero duration, multiple instructions
can be issued at the same time and those operand values should be appropriately
combined. In Qiskit Pulse we have set and shift type instructions for the frame control,
the set type instruction will be converted into the relevant shift amount for visualization.
Note that these instructions are not interchangeable and the order should be kept.
For example:
```python
sched1 = Schedule()
sched1 = sched1.insert(0, ShiftPhase(-1.57, DriveChannel(0))
sched1 = sched1.insert(0, SetPhase(3.14, DriveChannel(0))
sched2 = Schedule()
sched2 = sched2.insert(0, SetPhase(3.14, DriveChannel(0))
sched2 = sched2.insert(0, ShiftPhase(-1.57, DriveChannel(0))
```
In this example, ``sched1`` and ``sched2`` will have different frames.
On the drawer canvas, the total frame change amount of +3.14 should be shown for ``sched1``,
while `sched2` is +1.57. Since the `SetPhase` and the `ShiftPhase` instruction behave
differently, we cannot simply sum up the operand values in visualization output.
It should be also noted that zero duration instructions issued at the same time will be
overlapped on the canvas. Thus it is convenient to plot a total frame change amount rather
than plotting each operand value bound to the instruction.
"""
from collections import defaultdict
from typing import Dict, List, Iterator, Tuple
from qiskit import pulse
from qiskit.visualization.pulse_v2.types import PhaseFreqTuple
class ChannelEvents:
"""Channel event manager.
"""
_waveform_group = tuple((pulse.instructions.Play,
pulse.instructions.Delay,
pulse.instructions.Acquire))
_frame_group = tuple((pulse.instructions.SetFrequency,
pulse.instructions.ShiftFrequency,
pulse.instructions.SetPhase,
pulse.instructions.ShiftPhase))
def __init__(self,
waveforms: Dict[int, pulse.Instruction],
frames: Dict[int, List[pulse.Instruction]],
channel: pulse.channels.Channel):
"""Create new event manager.
Args:
waveforms: List of waveforms shown in this channel.
frames: List of frame change type instructions shown in this channel.
channel: Channel object associated with this manager.
"""
self._waveforms = waveforms
self._frames = frames
self.channel = channel
# initial frame
self.init_phase = 0
self.init_frequency = 0
@classmethod
def load_program(cls,
program: pulse.Schedule,
channel: pulse.channels.Channel):
"""Load a pulse program represented by ``Schedule``.
Args:
program: Target ``Schedule`` to visualize.
channel: The channel managed by this instance.
Returns:
ChannelEvents: The channel event manager for the specified channel.
"""
waveforms = dict()
frames = defaultdict(list)
# parse instructions
for t0, inst in program.filter(channels=[channel]).instructions:
if isinstance(inst, cls._waveform_group):
waveforms[t0] = inst
elif isinstance(inst, cls._frame_group):
frames[t0].append(inst)
return ChannelEvents(waveforms, frames, channel)
def is_empty(self):
"""Check if there is any nonzero waveforms in this channel."""
for waveform in self._waveforms.values():
if isinstance(waveform, (pulse.instructions.Play, pulse.instructions.Acquire)):
return False
return True
def get_waveforms(self) -> Iterator[Tuple[int, PhaseFreqTuple, pulse.Instruction]]:
"""Return waveform type instructions with frame."""
sorted_frame_changes = sorted(self._frames.items(), key=lambda x: x[0], reverse=True)
sorted_waveforms = sorted(self._waveforms.items(), key=lambda x: x[0])
# bind phase and frequency with instruction
phase = self.init_phase
frequency = self.init_frequency
for t0, inst in sorted_waveforms:
while len(sorted_frame_changes) > 0 and sorted_frame_changes[-1][0] <= t0:
_, frame_changes = sorted_frame_changes.pop()
for frame_change in frame_changes:
if isinstance(frame_change, pulse.instructions.SetFrequency):
frequency = frame_change.frequency
elif isinstance(frame_change, pulse.instructions.ShiftFrequency):
frequency += frame_change.frequency
elif isinstance(frame_change, pulse.instructions.SetPhase):
phase = frame_change.phase
elif isinstance(frame_change, pulse.instructions.ShiftPhase):
phase += frame_change.phase
frame = PhaseFreqTuple(phase, frequency)
yield t0, frame, inst
def get_frame_changes(self) -> Iterator[Tuple[int, PhaseFreqTuple, List[pulse.Instruction]]]:
"""Return frame change type instructions with total frame change amount."""
sorted_frame_changes = sorted(self._frames.items(), key=lambda x: x[0])
phase = self.init_phase
frequency = self.init_frequency
for t0, insts in sorted_frame_changes:
pre_phase = phase
pre_frequency = frequency
for inst in insts:
if isinstance(inst, pulse.instructions.SetFrequency):
frequency = inst.frequency
elif isinstance(inst, pulse.instructions.ShiftFrequency):
frequency += inst.frequency
elif isinstance(inst, pulse.instructions.SetPhase):
phase = inst.phase
elif isinstance(inst, pulse.instructions.ShiftPhase):
phase += inst.phase
frame = PhaseFreqTuple(phase - pre_phase, frequency - pre_frequency)
yield t0, frame, insts
|
py | 7dff30a3f9b473b9bf6ffcf7f7b9245175a4b198 | class Solution:
def twoSum(self, nums, target: int):
for i in range(0, len(nums)):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
return [i, j]
return []
def twoSum2(self, nums, target: int):
d = {}
for i in range(len(nums)):
left = target - nums[i]
if left in d:
return [i, d[left]]
d[nums[i]] = i
return []
s = Solution()
print(s.twoSum2([1,2,3], 5)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.