Datasets:

anton-l

/

python_sample_10k

like 0

aneeshpanoli/Algorithms

8901a9bc8923ef6bf9465f7d54f23050af0f963b

e95eca04bb2a9eb647d3e00f1b2c947d061b1ffe

/smallest_missing_pos_num.py

3b57977458de1f49537953210464cba6c59ccb9f

no_license

https://github.com/aneeshpanoli/Algorithms

dcdcfe9f4a4fb3ad8581cb6cfa4fe93b8651b750

a6d4273c0c70afe28364259b071d819757739ed2

refs/heads/master

__author__ = Aneesh panoli ''' find the smallest missing interger from an unsorted array CONSTRAINTS: - smallest postive integer MISSING - unsorted array EXAMPLE - a = [-1, 2, 0, 3, 4] - > 1 -a = [1, 2, 3, 4] -> 5 - = [1, 2, 5, 6] a = [-1] CLARIFYING QUESTIONS - are there duplicate numbers? - are are more than one missing number? - how large the numbers can be? - how large can be the array? INSIGHTS: - ignore less then zero - use a pointer to save the index of last seen PoA: EDGE cases: [-1, 2, 3, 4, 5] loop through from 1 and up a) sort array -> O(nlongn) + n ''' from typing import List def smallest_missing_positive_number1(a: List[int]) -> int: a = sorted(a) if a[-1] <= 0: return -1 for i in range(1, a[-1]): if i not in a: return i def smallest_missing_positive_number(a: List[int]) -> int: if not a: return -1 smallest = 1 while True: if smallest not in a: return smallest smallest += 1 print(smallest_missing_positive_number([1, 2, 3]))

UTF-8

Python

py

smallest_missing_pos_num.py

laetitia-lac/RandomMeals

ccac0ba6dc51de3b90819d285b3cc2f5dd501514

4ff4634de74e8282567ab5cf16cd070bc722c7d8

/src/main.py

d139cfebbaadda6e528f0d80f425270bc97e136c

permissive

https://github.com/laetitia-lac/RandomMeals

f48216327da6b1b6ecc19adae4c47806b42bda4b

2787b6e3bc69a06efa50ebb217e3aa8dc46be430

refs/heads/master

import json import random import fpdf from utils.logger import logger def return_content_json_file(path_file): with open(path_file, 'rb') as json_file: return json.load(json_file) def write_json_file(path_file, content_json): with open(path_file, 'w') as json_file: json.dump(content_json, json_file) def write_subpart_pdf(pdf_file, title_subpart, checkbox_content_subpart): # title subpart pdf_file.set_font('DejaVu', size=16) pdf_file.cell(40, 10, title_subpart) pdf_file.ln() # checkbox subpart pdf_file.set_font('DejaVu', size=12) for checkbox_line in checkbox_content_subpart: pdf_file.write(5, checkbox_line) pdf_file.ln() return pdf_file def write_pdf_file(path_file, chosen_recipes_names, shopping_list): pdf_file = fpdf.FPDF(format='A4') pdf_file.add_page() pdf_file.add_font('DejaVu', '', 'src/pdf_utils/DejaVuSans.ttf', uni=True) write_subpart_pdf(pdf_file, 'LISTE DE RECETTES DE LA SEMAINE', chosen_recipes_names) pdf_file.ln() write_subpart_pdf(pdf_file, 'LISTE DE COURSES POUR LA SEMAINE', shopping_list) pdf_file.output(path_file) if __name__ == '__main__': nb_of_recipes_to_choose = int(input('Indicate the number of meals to generate for this week: ')) logger.debug('Beginning of program') list_recipes = return_content_json_file('data/recipes.json') # get recipes of last week chosen_recipes_names_last_week = set(return_content_json_file('data/chosen_recipes.json')) logger.debug('Recipes of last week: {}'.format(chosen_recipes_names_last_week)) # choose the recipes for the week # 1. take recipes which were not selected last week all_recipes_names = {recipe['name_recipe'] for recipe in list_recipes} unused_recipes_names = all_recipes_names - chosen_recipes_names_last_week logger.debug('Unused recipes: {}'.format(unused_recipes_names)) chosen_recipes_names = random.sample(unused_recipes_names, k=min(nb_of_recipes_to_choose, len(unused_recipes_names))) # 2. if needed, take chosen recipes from last week nb_missing_recipes = nb_of_recipes_to_choose - len(chosen_recipes_names) if nb_missing_recipes > 0: chosen_recipes_names.extend( random.sample(chosen_recipes_names_last_week, k=min(nb_missing_recipes, len(chosen_recipes_names_last_week)))) logger.debug('Recipes of the week: {}'.format(chosen_recipes_names)) # output the chosen recipes of the week as json write_json_file('data/chosen_recipes.json', chosen_recipes_names) # get chosen recipes from the name chosen_recipes = [recipe for recipe in list_recipes if recipe['name_recipe'] in chosen_recipes_names] logger.debug('Recipes of the week (with list of ingredients): {}'.format(chosen_recipes)) # generate the shopping list shopping_list = dict() for recipe in chosen_recipes: for ingredient_recipe in recipe['ingredients']: ingredient_name = ingredient_recipe['name'].lower() ingredient_quantity = ingredient_recipe['quantity'] ingredient_unit = ingredient_recipe['unit'].lower() if ingredient_recipe.get('unit') else None logger.debug('Ingredient "{}" will be added to the shopping list (for recipe "{}")'.format(ingredient_name, recipe[ 'name_recipe'])) # add ingredient to shopping list ingredient_dict = shopping_list.get(ingredient_name, dict()) ingredient_dict[ingredient_unit] = ingredient_dict.get(ingredient_unit, 0) + ingredient_quantity shopping_list[ingredient_name] = ingredient_dict logger.debug('Shopping list: {}'.format(shopping_list)) # generate the output for user # 1. format chosen recipes names formatted_chosen_recipes_names = ['☐ {}'.format(recipe) for recipe in chosen_recipes_names] # 2. format shopping list formatted_shopping_list = list() name_ingredients_sorted = sorted(shopping_list.keys()) for name_ingredient in name_ingredients_sorted: for unit, quantity in shopping_list[name_ingredient].items(): formatted_shopping_list.append('☐ {} ({}{})'.format(name_ingredient, quantity, unit) if unit is not None else '☐ {} ({})'.format(name_ingredient, quantity)) logger.debug('Write output pdf') write_pdf_file('data/shopping_list.pdf', formatted_chosen_recipes_names, formatted_shopping_list) logger.debug('End of program')

UTF-8

Python

py

main.py

SayanNL1996/decorator_practice

a1c0a4faea2513f0fa36dbc1aa1f99bdeb7e8843

c0fd307be93a0997f458c0a4a0a99b3f73d2b263

/decorators(ex-8).py

cf0b4a39f5b9af53121b38a18c2460074fa71c3c

no_license

https://github.com/SayanNL1996/decorator_practice

86ebab2be7f878cb0530fbad10a01d0f37939fbd

6d0403dde3508bbad3c862faece0367f571aaa12

refs/heads/master

class Descriptor: def __init__(self): self.__fuel_cap = 0 def __get__(self, instance, owner): return self.__fuel_cap def __set__(self, instance, value): if isinstance(value, int): print(value) else: raise TypeError("Fuel Capacity can only be an integer") if value < 0: raise ValueError("Fuel Capacity can never be less than zero") self.__fuel_cap = value def __delete__(self, instance): del self.__fuel_cap class Car: fuel_cap = Descriptor() def __init__(self, make, model, fuel_cap): self.make = make self.model = model self.fuel_cap = fuel_cap def __str__(self): return "{0} model {1} with a fuel capacity of {2} ltr.".format(self.make, self.model, self.fuel_cap) car2 = Car("BMW", "X7", 40) print(car2)

UTF-8

Python

py

decorators(ex-8).py

MohamedAl-Hussein/FIFA

1f777cc27707d9da1dba193ff2573300577a7b8b

68f19e39de7dc5b716cb21791ac3e41a2979cbc6

/Docker/dags/archives/initdb_proxies.py

9a623d9cae45dfe8c4ec69f554ec26bca3366885

no_license

https://github.com/MohamedAl-Hussein/FIFA

71b1da6ca6d11ed819bafa61c31ba3bdfbaa3994

f226bd93de0d05e6a4e6abb0c72fe4636705ea65

refs/heads/master

# from datetime import datetime, timedelta # # # default_args = { # 'owner': 'airflow', # 'depends_on_past': False, # 'start_date': datetime.today(), # 'email_on_failure': False, # 'email_on_retry': False, # 'retries': 1, # 'retry_delay': timedelta(minutes=2) # } # # with DAG( # dag_id='initdb_proxies', # description="Import proxies into database.", # default_args=default_args, # schedule_interval='@once' # ) as dag: # # initproxydb_task = BashOperator( # task_id='proxy_initdb', # bash_command=\ # "cd /FIFA/fifa_data/ && python3 -m proxies.proxy_update ", # )

UTF-8

Python

py

initdb_proxies.py

flavone/DesignAndTestFramework

fdd7d1e383255399ba128bdc61ba6aaa9021a1ff

d14d2f1d0be2098be214cfb5793158fb27160f90

/app.py

5bff0f20621275987263a95eeda4fe2aec6adf26

no_license

https://github.com/flavone/DesignAndTestFramework

5f4e23b71a344f2aee6337d243b98862979d83d0

61cdae8795483ea5ed052571c407136cf52178c1

refs/heads/master

from flask import Flask from apis._api import api from ENV import * from apis.case_design_api import * from pylab import * mpl.rcParams['font.sans-serif'] = ['SimHei'] app = Flask(__name__) app.register_blueprint(api, url_prefix='/api') app.config['JSON_AS_ASCII'] = False if __name__ == '__main__': app.run(host=HOST, port=PORT, debug=True)

UTF-8

Python

py

app.py

DEMIDOB/Dassi

403d4f6a0bc67ba4213ce70911a7d6516171e434

3057614ed30c4e892e08d5e23db1e0675c84911a

/change_baa.py

f171f40f154bf61b4f540d2d7923e5c562f67dc1

no_license

https://github.com/DEMIDOB/Dassi

6ec997f640df85b5027ec2a320728a134d57ae43

004008ee109ee1e58db90b40ab8021c81884e746

refs/heads/master

import requests import os to = input("New backendaddr: ") pw = input("Your password: ") current_site = "https://demidob.000webhostapp.com/" # current_site = http://demidob.ml/ response = requests.post(current_site + "dassi/backendaddr/change.php", data={'pw':pw, 'to':to}) if response.status_code == 200: print(str(response.content)[2:len(str(response.content))-1]) os.system("pause")

UTF-8

Python

py

change_baa.py

minimalgeek/SQM-Model

f4918edab091211e34ac91cc5802e82b0293b2d1

dbe5968be87bf4600b69144468f669684993e9ce

/hu/farago/eum2/dto/Player.py

e1bfc5914cd035af2944e4ed4962ed15a30aed16

no_license

https://github.com/minimalgeek/SQM-Model

a1710f135cd72744a46912987ba662ca3d70d819

073d1b94edfdd5c430a4e7ed533ff233eee1ed1e

refs/heads/master

''' Created on 2016 máj. 19 @author: Balázs ''' import collections class Player(): ''' Player of EUM ''' previousPosition = None name = None capability = None position = None salience = None def __init__(self, name, capability, position, salience): self.name = name self.capability = float(capability) self.position = float(position) self.previousPosition = float(position) self.salience = float(salience) self.risk = 1 self.sumOfVotes = 0 self.probabilityOfSuccess = collections.OrderedDict() self.probabilityOfStatusQuo = collections.OrderedDict() self.expectedUtilityI = collections.OrderedDict() self.expectedUtilityJ = collections.OrderedDict() self.offers = collections.OrderedDict() self.bestOffer = None; def power(self): return self.capability*self.salience def addToSum(self, value): self.sumOfVotes += value def updatePosition(self, value): self.previousPosition = self.position self.position = value def __str__(self): return ','.join([self.name, str(self.capability), str(round(self.position, 3)), str(self.salience)]) def __repr__(self): return self.__str__()

UTF-8

Python

py

Player.py

ngocyen3006/learn-python

489f2c657c6e30ad40f072a944b45587ded18fcb

28129a9c44f3891eb5b3ce8c7fc530252b1c3840

/firecode.io/Level_03/array_partition.py

77fb0677e88290cc40b79cbe0ef6b57db339770e

no_license

https://github.com/ngocyen3006/learn-python

55eeb221f5a836ebee8c197fc3fddf6c585f02a6

ec2f35a87f846385f7353e7ef4900e5f80cfdb0a

refs/heads/master

# Array Partition def find_partitions(input_list): res = [] n = input_list[0] i = 1 while i < len(input_list) and input_list[i] == input_list[i - 1] + 1: i += 1 try: if n == input_list[i - 1]: res.append(n) else: res.append(str(n) + "-" + str(input_list[i - 1])) return res + find_partitions(input_list[i:]) except IndexError: return res if __name__ == '__main__': a = [1, 2, 3, 6, 7, 8, 10, 11] r_a = ["1-3", "6-8", "10-11"] print(find_partitions(a) == r_a) print("-" * 25) a = [1, 2, 3, 4, 7, 8, 9] r_a = ["1-4", "7-9"] print(find_partitions(a) == r_a) print("-" * 25) a = [1, 3, 7, 8, 9] r_a = [1, 3, "7-9"] print(find_partitions(a) == r_a) print("-" * 25)

UTF-8

Python

py

array_partition.py

elvinMark/emmv

bc6aa1829fb9c9fdf4465fc2b1f4974a7c25fcf0

02fddf4807f45490a6eb63dbedecf4a9ace2758d

/Caja/src/tmp/caja.py

23e50bf9a1dc82b962c25761f102a89f0761f8a8

no_license

https://github.com/elvinMark/emmv

91c4464e67a79a86dc45b159aa9c54b123c4adc7

20543b50e6f4ddb8bb1c2dd711fa361b9eff3bff

refs/heads/master

# -*- coding: utf-8 -*- # Form implementation generated from reading ui file './ui/caja.ui' # # Created by: PyQt5 UI code generator 5.14.1 # # WARNING! All changes made in this file will be lost! from PyQt5 import QtCore, QtGui, QtWidgets class Ui_MainWindow(object): def setupUi(self, MainWindow): MainWindow.setObjectName("MainWindow") MainWindow.resize(502, 146) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(MainWindow.sizePolicy().hasHeightForWidth()) MainWindow.setSizePolicy(sizePolicy) self.centralwidget = QtWidgets.QWidget(MainWindow) self.centralwidget.setObjectName("centralwidget") self.verticalLayoutWidget = QtWidgets.QWidget(self.centralwidget) self.verticalLayoutWidget.setGeometry(QtCore.QRect(20, 10, 287, 80)) self.verticalLayoutWidget.setObjectName("verticalLayoutWidget") self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget) self.verticalLayout.setContentsMargins(0, 0, 0, 0) self.verticalLayout.setObjectName("verticalLayout") self.horizontalLayout = QtWidgets.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.label = QtWidgets.QLabel(self.verticalLayoutWidget) self.label.setObjectName("label") self.horizontalLayout.addWidget(self.label) self.dateEdit = QtWidgets.QDateEdit(self.verticalLayoutWidget) self.dateEdit.setEnabled(True) self.dateEdit.setReadOnly(True) self.dateEdit.setCalendarPopup(True) self.dateEdit.setObjectName("dateEdit") self.horizontalLayout.addWidget(self.dateEdit) self.verticalLayout.addLayout(self.horizontalLayout) self.horizontalLayout_2 = QtWidgets.QHBoxLayout() self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.pushButton = QtWidgets.QPushButton(self.verticalLayoutWidget) self.pushButton.setObjectName("pushButton") self.horizontalLayout_2.addWidget(self.pushButton) spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_2.addItem(spacerItem) self.verticalLayout.addLayout(self.horizontalLayout_2) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 502, 22)) self.menubar.setObjectName("menubar") self.menuIngresos = QtWidgets.QMenu(self.menubar) self.menuIngresos.setObjectName("menuIngresos") self.menuEgresos = QtWidgets.QMenu(self.menubar) self.menuEgresos.setObjectName("menuEgresos") self.menuConsulta = QtWidgets.QMenu(self.menubar) self.menuConsulta.setObjectName("menuConsulta") self.menuReporte = QtWidgets.QMenu(self.menubar) self.menuReporte.setObjectName("menuReporte") self.menuAdministrador = QtWidgets.QMenu(self.menubar) self.menuAdministrador.setObjectName("menuAdministrador") MainWindow.setMenuBar(self.menubar) self.statusbar = QtWidgets.QStatusBar(MainWindow) self.statusbar.setObjectName("statusbar") MainWindow.setStatusBar(self.statusbar) self.actionEfectivo = QtWidgets.QAction(MainWindow) self.actionEfectivo.setObjectName("actionEfectivo") self.actionCheque = QtWidgets.QAction(MainWindow) self.actionCheque.setObjectName("actionCheque") self.actionVoucher = QtWidgets.QAction(MainWindow) self.actionVoucher.setObjectName("actionVoucher") self.actionGastos = QtWidgets.QAction(MainWindow) self.actionGastos.setObjectName("actionGastos") self.actionCrear_Codigo = QtWidgets.QAction(MainWindow) self.actionCrear_Codigo.setObjectName("actionCrear_Codigo") self.actionLista_de_Codigos = QtWidgets.QAction(MainWindow) self.actionLista_de_Codigos.setObjectName("actionLista_de_Codigos") self.actionIngresos = QtWidgets.QAction(MainWindow) self.actionIngresos.setObjectName("actionIngresos") self.actionEgresos = QtWidgets.QAction(MainWindow) self.actionEgresos.setObjectName("actionEgresos") self.actionReporte_de_Caja = QtWidgets.QAction(MainWindow) self.actionReporte_de_Caja.setObjectName("actionReporte_de_Caja") self.menuIngresos.addAction(self.actionEfectivo) self.menuIngresos.addAction(self.actionCheque) self.menuIngresos.addAction(self.actionVoucher) self.menuEgresos.addAction(self.actionGastos) self.menuConsulta.addAction(self.actionIngresos) self.menuConsulta.addAction(self.actionEgresos) self.menuReporte.addAction(self.actionReporte_de_Caja) self.menuAdministrador.addAction(self.actionCrear_Codigo) self.menuAdministrador.addAction(self.actionLista_de_Codigos) self.menubar.addAction(self.menuAdministrador.menuAction()) self.menubar.addAction(self.menuIngresos.menuAction()) self.menubar.addAction(self.menuEgresos.menuAction()) self.menubar.addAction(self.menuConsulta.menuAction()) self.menubar.addAction(self.menuReporte.menuAction()) self.retranslateUi(MainWindow) self.pushButton.clicked.connect(MainWindow.enable_date_edit) self.actionCrear_Codigo.triggered.connect(MainWindow.window_create_code) self.actionCheque.triggered.connect(MainWindow.window_input_check) self.actionEfectivo.triggered.connect(MainWindow.window_input_cash) self.actionVoucher.triggered.connect(MainWindow.window_input_ticket) self.actionLista_de_Codigos.triggered.connect(MainWindow.window_list_code) self.actionGastos.triggered.connect(MainWindow.window_output_expenses) self.actionIngresos.triggered.connect(MainWindow.window_consult_inputs) self.actionEgresos.triggered.connect(MainWindow.window_consult_outputs) self.actionReporte_de_Caja.triggered.connect(MainWindow.window_report_all) self.dateEdit.dateChanged['QDate'].connect(MainWindow.change_system_date) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "Caja - EMMV")) self.label.setText(_translate("MainWindow", "Fecha:")) self.pushButton.setText(_translate("MainWindow", "Cambiar Fecha")) self.menuIngresos.setTitle(_translate("MainWindow", "Ingresos")) self.menuEgresos.setTitle(_translate("MainWindow", "Egresos")) self.menuConsulta.setTitle(_translate("MainWindow", "Consulta")) self.menuReporte.setTitle(_translate("MainWindow", "Reporte")) self.menuAdministrador.setTitle(_translate("MainWindow", "Administrador")) self.actionEfectivo.setText(_translate("MainWindow", "Efectivo")) self.actionCheque.setText(_translate("MainWindow", "Cheque")) self.actionVoucher.setText(_translate("MainWindow", "Voucher")) self.actionGastos.setText(_translate("MainWindow", "Gastos")) self.actionCrear_Codigo.setText(_translate("MainWindow", "Crear Codigo")) self.actionLista_de_Codigos.setText(_translate("MainWindow", "Lista de Codigos")) self.actionIngresos.setText(_translate("MainWindow", "Ingresos")) self.actionEgresos.setText(_translate("MainWindow", "Egresos")) self.actionReporte_de_Caja.setText(_translate("MainWindow", "Reporte de Caja"))

UTF-8

Python

py

caja.py

zziri/study

c4283ea829dc12378e1166f6489b0bba3f443c5e

323eb296cbf740ad6bf678fb15e48f0315b66824

/ps/BOJ/16194 카드 구매하기 2.py

598bc9c6e24ecffcc56932b02784690bc042dee3

no_license

https://github.com/zziri/study

0da83d87247dafb1083b6068e9b6354cb960af0c

b0eded396c5201283db2d7f45b66d19d3f2831b4

refs/heads/master

def solution(n, p): dp = [987654321]*(n+1) dp[0] = 0 for i in range(1, n+1): for j in range(1, i+1): dp[i] = min(dp[i], dp[i-j] + p[j]) return dp[n] def main(): # input n = int(input()) p = [0] for item in list(map(int, input().split())): p.append(item) # solve answer = solution(n, p) # print print(answer) if __name__ == "__main__": main()

UTF-8

Python

py

16194 카드 구매하기 2.py

yigitozgumus/IACV_Project

33fd50f3ebc54c948faff41a5d25565a35b310d9

71e15712c6583d7c1ae1b24e42dbd8ddb5872e66

/models/cvae_denoiser.py

b60c86e765ef5c046b007af28b84e6d798396bea

permissive

https://github.com/yigitozgumus/IACV_Project

4968fc1e4a95b5f05dcf164fb5b2749326095343

0e012139a33c76ca88505c28270f1250181ec701

refs/heads/master

MIT

Python

from base.base_model import BaseModel import tensorflow as tf from utils.utils import get_getter import numpy as np class CVAEDenoiser(BaseModel): def __init__(self, config): super(CVAEDenoiser, self).__init__(config) self.build_model() self.init_saver() def build_model(self): # Placeholders self.is_training_ae = tf.placeholder(tf.bool) # self.is_training_den = tf.placeholder(tf.bool) self.image_input = tf.placeholder( tf.float32, shape=[None] + self.config.trainer.image_dims, name="x" ) self.ground_truth = tf.placeholder( tf.float32, shape=[None] + self.config.trainer.image_dims, name="gt" ) self.noise_tensor = tf.placeholder( tf.float32, shape=[None] + self.config.trainer.image_dims, name="noise" ) self.init_kernel = tf.random_normal_initializer(mean=0.0, stddev=0.02) self.batch_size = tf.placeholder(tf.int32) ## Architecture # Encoder Decoder Part first self.logger.info("Building Training Graph") with tf.variable_scope("CVAE_Denoiser"): with tf.variable_scope("CVAE"): self.mean, self.logvar = self.encoder(self.image_input) self.z_reparam = self.reparameterize(self.mean, self.logvar, self.batch_size) self.rec_image = self.decoder(self.z_reparam, apply_sigmoid=True) with tf.variable_scope("Denoiser"): self.denoised, self.mask, self.mask_shallow = self.denoiser(self.rec_image + self.noise_tensor) # Loss Function with tf.name_scope("Loss_Function"): with tf.name_scope("CVAE"): self.reconstruction_loss = -tf.reduce_sum( self.image_input * tf.log(1e-10 + self.rec_image) + (1 - self.image_input) * tf.log(1e-10 + (1 - self.rec_image)), 1, ) self.latent_loss = -0.5 * tf.reduce_sum( 1 + self.logvar - tf.square(self.mean) - tf.exp(self.logvar), 1 ) self.cvae_loss = tf.reduce_mean(self.reconstruction_loss + self.latent_loss) with tf.name_scope("Denoiser"): delta_den = self.denoised - self.image_input delta_den = tf.layers.Flatten()(delta_den) self.den_loss = tf.reduce_mean( tf.norm( delta_den, ord=self.config.trainer.den_norm_degree, axis=1, keepdims=False ) ) # Optimizer with tf.name_scope("Optimizer"): self.optimizer = tf.train.AdamOptimizer( self.config.trainer.l_rate, beta1=self.config.trainer.optimizer_adam_beta1, beta2=self.config.trainer.optimizer_adam_beta2, ) # Collect All Variables all_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES) self.cvae_vars = [v for v in all_variables if v.name.startswith("CVAE_Denoiser/CVAE")] self.denoiser_vars = [ v for v in all_variables if v.name.startswith("CVAE_Denoiser/Denoiser") ] self.cvae_update_ops = tf.get_collection( tf.GraphKeys.UPDATE_OPS, scope="CVAE_Denoiser/CVAE" ) self.den_update_ops = tf.get_collection( tf.GraphKeys.UPDATE_OPS, scope="CVAE_Denoiser/Denoiser" ) with tf.control_dependencies(self.cvae_update_ops): self.cvae_op = self.optimizer.minimize( self.cvae_loss, var_list=self.cvae_vars, global_step=self.global_step_tensor ) with tf.control_dependencies(self.den_update_ops): self.den_op = self.optimizer.minimize(self.den_loss, var_list=self.denoiser_vars) # Exponential Moving Average for Estimation self.cvae_ema = tf.train.ExponentialMovingAverage(decay=self.config.trainer.ema_decay) maintain_averages_op_cvae = self.cvae_ema.apply(self.cvae_vars) self.den_ema = tf.train.ExponentialMovingAverage(decay=self.config.trainer.ema_decay) maintain_averages_op_den = self.den_ema.apply(self.denoiser_vars) with tf.control_dependencies([self.cvae_op]): self.train_cvae_op = tf.group(maintain_averages_op_cvae) with tf.control_dependencies([self.den_op]): self.train_den_op = tf.group(maintain_averages_op_den) self.logger.info("Building Testing Graph...") with tf.variable_scope("CVAE_Denoiser"): with tf.variable_scope("CVAE"): self.mean_ema, self.logvar_ema = self.encoder( self.image_input, getter=get_getter(self.cvae_ema) ) self.z_reparam_ema = self.reparameterize( self.mean_ema, self.logvar_ema, self.batch_size ) self.rec_image_ema = self.decoder( self.z_reparam_ema, getter=get_getter(self.cvae_ema), apply_sigmoid=True ) with tf.variable_scope("Denoiser"): self.denoised_ema, self.mask_ema, self.mask_shallow_ema = self.denoiser( self.rec_image_ema, getter=get_getter(self.den_ema) ) self.mean_den_ema, self.logvar_den_ema = self.encoder( self.denoised_ema, getter=get_getter(self.cvae_ema) ) self.z_den_ema = self.reparameterize( self.mean_den_ema, self.logvar_den_ema, self.batch_size ) self.residual = self.image_input - self.mask_ema with tf.name_scope("Testing"): with tf.variable_scope("Reconstruction_Loss"): # |x - D(E(x)) |2 delta = self.rec_image_ema - self.image_input delta = tf.layers.Flatten()(delta) self.rec_score = tf.norm(delta, ord=2, axis=1, keepdims=False) with tf.variable_scope("Denoising_Loss"): delta_den = self.denoised_ema - self.rec_image_ema delta_den = tf.layers.Flatten()(delta_den) self.den_score = tf.norm(delta_den, ord=2, axis=1, keepdims=False) with tf.variable_scope("Pipeline_Loss_1"): delta_pipe = self.denoised_ema - self.image_input delta_pipe = tf.layers.Flatten()(delta_pipe) self.pipe_score = tf.norm(delta_pipe, ord=1, axis=1, keepdims=False) with tf.variable_scope("Pipeline_Loss_2"): delta_pipe = self.denoised_ema - self.image_input delta_pipe = tf.layers.Flatten()(delta_pipe) self.pipe_score_2 = tf.norm(delta_pipe, ord=2, axis=1, keepdims=False) with tf.variable_scope("Combination_Loss"): delta_comb = self.z_reparam_ema - self.z_den_ema delta_comb = tf.layers.Flatten()(delta_comb) comb_score = tf.norm(delta_comb, ord=2, axis=1, keepdims=False) self.noise_score = comb_score self.comb_score = 10 * comb_score + self.pipe_score with tf.variable_scope("Mask_1"): delta_mask = (self.rec_image_ema - self.mask_ema) delta_mask = tf.layers.Flatten()(delta_mask) self.mask_score_1 = tf.norm(delta_mask, ord=1,axis=1,keepdims=False) with tf.variable_scope("Mask_2"): delta_mask_2 = (self.image_input - self.mask_ema) delta_mask_2 = tf.layers.Flatten()(delta_mask_2) self.mask_score_2 = tf.norm(delta_mask_2, ord=2,axis=1,keepdims=False) with tf.variable_scope("Mask_1_s"): delta_mask = (self.rec_image_ema - self.mask_shallow_ema) delta_mask = tf.layers.Flatten()(delta_mask) self.mask_score_1_s = tf.norm(delta_mask, ord=1,axis=1,keepdims=False) with tf.variable_scope("Mask_2_s"): delta_mask_2 = (self.image_input - self.mask_shallow_ema) delta_mask_2 = tf.layers.Flatten()(delta_mask_2) self.mask_score_2_s = tf.norm(delta_mask_2, ord=2,axis=1,keepdims=False) # Summary with tf.name_scope("Summary"): with tf.name_scope("cvae_loss"): tf.summary.scalar("loss_auto", self.cvae_loss, ["loss_cvae"]) with tf.name_scope("denoiser_loss"): tf.summary.scalar("loss_den", self.den_loss, ["loss_den"]) with tf.name_scope("Image"): tf.summary.image("Input_Image", self.image_input, 1, ["image"]) tf.summary.image("rec_image", self.rec_image, 1, ["image"]) tf.summary.image("Input_Image", self.image_input, 1, ["image_2"]) tf.summary.image("rec_image", self.rec_image, 1, ["image_2"]) tf.summary.image("Denoised_Image", self.denoised, 1, ["image_2"]) tf.summary.image("mask", self.mask, 1, ["image_2"]) tf.summary.image("mask", self.mask_ema, 1, ["image_3"]) tf.summary.image("mask_shallow", self.mask_shallow_ema, 1, ["image_3"]) tf.summary.image("Output_Image", self.denoised_ema, 1, ["image_3"]) tf.summary.image("Rec_Image", self.rec_image_ema, 1, ["image_3"]) tf.summary.image("Input_Image", self.image_input, 1, ["image_3"]) tf.summary.image("Residual", self.residual,1,["image_3"]) tf.summary.image("Ground_Truth", self.ground_truth,1,["image_3"]) self.summary_op_cvae = tf.summary.merge_all("image") self.summary_op_den = tf.summary.merge_all("image_2") self.summary_op_test = tf.summary.merge_all("image_3") self.summary_op_loss_cvae = tf.summary.merge_all("loss_cvae") self.summary_op_loss_den = tf.summary.merge_all("loss_den") # self.summary_all_cvae = tf.summary.merge([self.summary_op_cvae, self.summary_op_loss_cvae]) # self.summary_all_den = tf.summary.merge([self.summary_op_den, self.summary_op_loss_den]) # self.summary_all = tf.summary.merge([self.summary_op_im, self.summary_op_loss]) def encoder(self, image_input, getter=None): # This generator will take the image from the input dataset, and first it will # it will create a latent representation of that image then with the decoder part, # it will reconstruct the image. with tf.variable_scope("Inference", custom_getter=getter, reuse=tf.AUTO_REUSE): x_e = tf.reshape( image_input, [-1, self.config.data_loader.image_size, self.config.data_loader.image_size, 1], ) net_name = "Layer_1" with tf.variable_scope(net_name): x_e = tf.layers.Conv2D( filters=128, kernel_size=5, strides=(2, 2), padding="same", kernel_initializer=self.init_kernel, name="conv", )(x_e) x_e = tf.nn.leaky_relu( features=x_e, alpha=self.config.trainer.leakyReLU_alpha, name="leaky_relu" ) # 14 x 14 x 64 net_name = "Layer_2" with tf.variable_scope(net_name): x_e = tf.layers.Conv2D( filters=256, kernel_size=5, padding="same", strides=(2, 2), kernel_initializer=self.init_kernel, name="conv", )(x_e) # x_e = tf.layers.batch_normalization( # x_e, # momentum=self.config.trainer.batch_momentum, # epsilon=self.config.trainer.batch_epsilon, # training=self.is_training_ae, # ) x_e = tf.nn.leaky_relu( features=x_e, alpha=self.config.trainer.leakyReLU_alpha, name="leaky_relu" ) # 7 x 7 x 128 net_name = "Layer_3" with tf.variable_scope(net_name): x_e = tf.layers.Conv2D( filters=512, kernel_size=5, padding="same", strides=(2, 2), kernel_initializer=self.init_kernel, name="conv", )(x_e) # x_e = tf.layers.batch_normalization( # x_e, # momentum=self.config.trainer.batch_momentum, # epsilon=self.config.trainer.batch_epsilon, # training=self.is_training_ae, # ) x_e = tf.nn.leaky_relu( features=x_e, alpha=self.config.trainer.leakyReLU_alpha, name="leaky_relu" ) # 4 x 4 x 256 x_e = tf.layers.Flatten()(x_e) net_name = "Layer_4" with tf.variable_scope(net_name): x_e = tf.layers.Dense( units=self.config.trainer.noise_dim + self.config.trainer.noise_dim, kernel_initializer=self.init_kernel, name="fc", )(x_e) mean, logvar = tf.split(x_e, num_or_size_splits=2, axis=1) return mean, logvar def decoder(self, noise_input, getter=None, apply_sigmoid=False): with tf.variable_scope("Generative", custom_getter=getter, reuse=tf.AUTO_REUSE): net = tf.reshape(noise_input, [-1, 1, 1, self.config.trainer.noise_dim]) net_name = "layer_1" with tf.variable_scope(net_name): net = tf.layers.Conv2DTranspose( filters=512, kernel_size=5, strides=(2, 2), padding="same", kernel_initializer=self.init_kernel, name="tconv1", )(net) net = tf.nn.relu(features=net, name="tconv1/relu") net_name = "layer_2" with tf.variable_scope(net_name): net = tf.layers.Conv2DTranspose( filters=256, kernel_size=5, strides=(2, 2), padding="same", kernel_initializer=self.init_kernel, name="tconv2", )(net) net = tf.nn.relu(features=net, name="tconv2/relu") net_name = "layer_3" with tf.variable_scope(net_name): net = tf.layers.Conv2DTranspose( filters=128, kernel_size=5, strides=(2, 2), padding="same", kernel_initializer=self.init_kernel, name="tconv3", )(net) net = tf.nn.relu(features=net, name="tconv3/relu") net_name = "layer_4" with tf.variable_scope(net_name): net = tf.layers.Conv2DTranspose( filters=64, kernel_size=5, strides=(2, 2), padding="same", kernel_initializer=self.init_kernel, name="tconv4", )(net) net = tf.nn.relu(features=net, name="tconv3/relu") net_name = "layer_5" with tf.variable_scope(net_name): net = tf.layers.Conv2DTranspose( filters=1, kernel_size=5, strides=(2, 2), padding="same", kernel_initializer=self.init_kernel, name="tconv5", )(net) if apply_sigmoid: net = tf.sigmoid(net) return net def denoiser(self, image_input, getter=None): # Full Model Scope with tf.variable_scope("Denoiser", reuse=tf.AUTO_REUSE, custom_getter=getter): # First Convolution + ReLU layer net = tf.layers.Conv2D( filters=63, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(image_input) net = tf.nn.relu(features=net) # 1 Convolution of the image for the bottom layer net_input = tf.layers.Conv2D( filters=1, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(image_input) net_layer_1 = tf.layers.Conv2D( filters=1, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(net) # First convolution from the image second one from the first top layer convolution mask = net_input + net_layer_1 for i in range(4): # Top layer chained convolutions net = tf.layers.Conv2D( filters=63, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(net) net = tf.nn.relu(features=net) # Bottom layer single convolutions net_1 = tf.layers.Conv2D( filters=1, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(net) mask += net_1 mask_shallow = mask for i in range(5): # Top layer chained convolutions net = tf.layers.Conv2D( filters=63, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(net) net = tf.nn.relu(features=net) # Bottom layer single convolutions net_1 = tf.layers.Conv2D( filters=1, kernel_size=3, strides=1, kernel_initializer=self.init_kernel, padding="same", )(net) mask += net_1 output = image_input + mask return output, mask, mask_shallow def kl_loss(self, avg, log_var): with tf.name_scope("KLLoss"): return tf.reduce_mean( -0.5 * tf.reduce_sum(1.0 + log_var - tf.square(avg) - tf.exp(log_var), axis=-1) ) def reparameterize(self, mean, logvar, batch_size): eps = tf.random_normal(shape=[batch_size, self.config.trainer.noise_dim]) return eps * tf.exp(logvar * 0.5) + mean def log_normal_pdf(self, sample, mean, logvar, raxis=1): log2pi = tf.log(2.0 * np.pi) return tf.reduce_sum( -0.5 * ((sample - mean) ** 2.0 * tf.exp(-logvar) + logvar + log2pi), axis=raxis ) def init_saver(self): # here you initialize the tensorflow saver that will be used in saving the checkpoints. self.saver = tf.train.Saver(max_to_keep=self.config.log.max_to_keep)

UTF-8

Python

py

cvae_denoiser.py

mrijken/poetry

173d5c950ef57e77137ca80802b02a05f6b6febb

bf882815b85c7b6143f299144a6bedbfb5b9b7f3

/poetry/utils/_compat.py

937f9b300e6135a3b1897a6eebb37356eb614400

permissive

https://github.com/mrijken/poetry

7ae86534f350182fdbad0a5966e1dffb6a914a14

e445ec4f718fa2933a3a20025e24d2352a61634a

refs/heads/master

MIT

import sys try: from functools32 import lru_cache except ImportError: from functools import lru_cache try: from glob2 import glob except ImportError: from glob import glob try: import zipfile as zipp from importlib import metadata except ImportError: import importlib_metadata as metadata import zipp try: import urllib.parse as urlparse except ImportError: import urlparse try: from os import cpu_count except ImportError: # Python 2 from multiprocessing import cpu_count try: # Python 2 long = long unicode = unicode basestring = basestring except NameError: # Python 3 long = int unicode = str basestring = str PY2 = sys.version_info[0] == 2 PY34 = sys.version_info >= (3, 4) PY35 = sys.version_info >= (3, 5) PY36 = sys.version_info >= (3, 6) WINDOWS = sys.platform == "win32" try: from shlex import quote except ImportError: # PY2 from pipes import quote # noqa if PY34: from importlib.machinery import EXTENSION_SUFFIXES else: from imp import get_suffixes EXTENSION_SUFFIXES = [suffix[0] for suffix in get_suffixes()] if PY35: from pathlib import Path else: from pathlib2 import Path if not PY36: from collections import OrderedDict else: OrderedDict = dict if PY35: import subprocess as subprocess from subprocess import CalledProcessError else: import subprocess32 as subprocess from subprocess32 import CalledProcessError if PY34: # subprocess32 pass the calls directly to subprocess # on Python 3.3+ but Python 3.4 does not provide run() # so we backport it import signal from subprocess import PIPE from subprocess import Popen from subprocess import SubprocessError from subprocess import TimeoutExpired class CalledProcessError(SubprocessError): """Raised when run() is called with check=True and the process returns a non-zero exit status. Attributes: cmd, returncode, stdout, stderr, output """ def __init__(self, returncode, cmd, output=None, stderr=None): self.returncode = returncode self.cmd = cmd self.output = output self.stderr = stderr def __str__(self): if self.returncode and self.returncode < 0: try: return "Command '%s' died with %r." % ( self.cmd, signal.Signals(-self.returncode), ) except ValueError: return "Command '%s' died with unknown signal %d." % ( self.cmd, -self.returncode, ) else: return "Command '%s' returned non-zero exit status %d." % ( self.cmd, self.returncode, ) @property def stdout(self): """Alias for output attribute, to match stderr""" return self.output @stdout.setter def stdout(self, value): # There's no obvious reason to set this, but allow it anyway so # .stdout is a transparent alias for .output self.output = value class CompletedProcess(object): """A process that has finished running. This is returned by run(). Attributes: args: The list or str args passed to run(). returncode: The exit code of the process, negative for signals. stdout: The standard output (None if not captured). stderr: The standard error (None if not captured). """ def __init__(self, args, returncode, stdout=None, stderr=None): self.args = args self.returncode = returncode self.stdout = stdout self.stderr = stderr def __repr__(self): args = [ "args={!r}".format(self.args), "returncode={!r}".format(self.returncode), ] if self.stdout is not None: args.append("stdout={!r}".format(self.stdout)) if self.stderr is not None: args.append("stderr={!r}".format(self.stderr)) return "{}({})".format(type(self).__name__, ", ".join(args)) def check_returncode(self): """Raise CalledProcessError if the exit code is non-zero.""" if self.returncode: raise CalledProcessError( self.returncode, self.args, self.stdout, self.stderr ) def run(*popenargs, **kwargs): """Run command with arguments and return a CompletedProcess instance. The returned instance will have attributes args, returncode, stdout and stderr. By default, stdout and stderr are not captured, and those attributes will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them. If check is True and the exit code was non-zero, it raises a CalledProcessError. The CalledProcessError object will have the return code in the returncode attribute, and output & stderr attributes if those streams were captured. If timeout is given, and the process takes too long, a TimeoutExpired exception will be raised. There is an optional argument "input", allowing you to pass a string to the subprocess's stdin. If you use this argument you may not also use the Popen constructor's "stdin" argument, as it will be used internally. The other arguments are the same as for the Popen constructor. If universal_newlines=True is passed, the "input" argument must be a string and stdout/stderr in the returned object will be strings rather than bytes. """ input = kwargs.pop("input", None) timeout = kwargs.pop("timeout", None) check = kwargs.pop("check", False) if input is not None: if "stdin" in kwargs: raise ValueError("stdin and input arguments may not both be used.") kwargs["stdin"] = PIPE process = Popen(*popenargs, **kwargs) try: process.__enter__() # No-Op really... illustrate "with in 2.4" try: stdout, stderr = process.communicate(input, timeout=timeout) except TimeoutExpired: process.kill() stdout, stderr = process.communicate() raise TimeoutExpired( process.args, timeout, output=stdout, stderr=stderr ) except: process.kill() process.wait() raise retcode = process.poll() if check and retcode: raise CalledProcessError( retcode, process.args, output=stdout, stderr=stderr ) finally: # None because our context manager __exit__ does not use them. process.__exit__(None, None, None) return CompletedProcess(process.args, retcode, stdout, stderr) subprocess.run = run subprocess.CalledProcessError = CalledProcessError def decode(string, encodings=None): if not PY2 and not isinstance(string, bytes): return string if PY2 and isinstance(string, unicode): return string encodings = encodings or ["utf-8", "latin1", "ascii"] for encoding in encodings: try: return string.decode(encoding) except (UnicodeEncodeError, UnicodeDecodeError): pass return string.decode(encodings[0], errors="ignore") def encode(string, encodings=None): if not PY2 and isinstance(string, bytes): return string if PY2 and isinstance(string, str): return string encodings = encodings or ["utf-8", "latin1", "ascii"] for encoding in encodings: try: return string.encode(encoding) except (UnicodeEncodeError, UnicodeDecodeError): pass return string.encode(encodings[0], errors="ignore") def to_str(string): if isinstance(string, str) or not isinstance(string, (unicode, bytes)): return string if PY2: method = "encode" else: method = "decode" encodings = ["utf-8", "latin1", "ascii"] for encoding in encodings: try: return getattr(string, method)(encoding) except (UnicodeEncodeError, UnicodeDecodeError): pass return getattr(string, method)(encodings[0], errors="ignore") def list_to_shell_command(cmd): return " ".join( '"{}"'.format(token) if " " in token and token[0] not in {"'", '"'} else token for token in cmd )

UTF-8

Python

py

_compat.py

leezqcst/rs

016c7716a053b81df6fa833519c3217668b6dad1

21e84366ef36fb7aca1657473ac978f962f3b4ea

/rs/CBR/test.py

540d56329b3bc8313824b6a80819e8ddd127744b

no_license

https://github.com/leezqcst/rs

c53831e51df71a43797d90bd8ddf3b448e5e5186

5adf8a667e00f2c3cdc412cb5c429b702046f28b

refs/heads/master

# -*- coding: utf-8 -*- import sys reload(sys) sys.setdefaultencoding('utf-8') sys.path.append('./..') from docs import Documents from CBR import CBR def show_news_create_time(): global x local_news = x.get_all_info() for line in local_news: print line.get_create_time() def test_encoding(): s='2014年03月08日12:31' print s.split('年') ''' for i in range(10): print 'parse: ',x.get_all_info()[i].get_userid() print 'parse: ',x.get_all_info()[i].get_newsid() print 'parse: ',x.get_all_info()[i].get_title() print 'parse: ',x.get_all_info()[i].get_tags() ''' def test_cbr(target_reader_list = []): input_target_len = len(target_reader_list) #use training data to build user vector testing = Documents('user_click_data.txt',True) test_news = testing.get_AllNews() user_read_dict = dict() target_reader = [] #you can specify the target_reader number here!!!! target_num = 5 if input_target_len != 0: target_num = input_target_len get = 0 while len(target_reader)<(target_num): utemp = test_news[get].get_userid() get += 1 if not utemp in target_reader: target_reader.append(utemp) if input_target_len != 0: target_reader = target_reader_list training = Documents('user_click_data.txt',True) train_news = training.get_AllNews() cbr = CBR(train_news) cbr.build_user_vector(target_reader) cbr.transform_user_vector() for i in test_news: uid = i.get_userid() nid = i.get_newsid() if uid in target_reader: pass else: #print uid target_reader.append(uid) if uid in user_read_dict: user_read_dict[uid].append(nid) else: user_read_dict[uid] = [] user_read_dict[uid].append(nid) #if you want to specify the target_readerlist, you can uncomment the folllwing line #target_reader = target_reader_list #print target_reader for i in range(target_num): recommend = cbr.get_recommendation_list(target_reader[i],test_news) #print 'recommend: ',recommend #print 'real: ',user_read_dict[target_reader[i]] temp = [] for item in recommend: temp.append(item[0]) count_read = 0 count = 0 for t in user_read_dict[target_reader[i]]: count_read += 1 if t in temp: count += 1 print 'reader ',target_reader[i],' read:',len(user_read_dict[target_reader[i]]),' accept: ',count def test_sort(): show_news_create_time() global x local_news = x.get_all_info() news = Documents.sort_news_by_time(local_news); print '____________________________________________________' for i in news: print i.get_create_time()#do not new.get here test_cbr([5218791,52550])

UTF-8

Python

py

test.py

kazusa4418/PythonTraining

af7b6313244d87d8b6564d16643eccf72f501a69

f7e1e2657fa4636e2ff8769a3ee4113c2697fd3a

/set-in.py

61a8bcf85f8b44f4ced053539bda0300d89d472d

no_license

https://github.com/kazusa4418/PythonTraining

1ae868252bd921d985c034ad2a5d6ccb6cdc190e

0560c229073f85f0c6988dce73bcb384acd681ae

refs/heads/master

# box3 にベンチが入っているか調べる box3 = {"ハンマー", "釘", "ベンチ"} flag = "ベンチ" in box3 print(flag)

UTF-8

Python

py

set-in.py

adamkittel/src

a3b4bce654bbfe849c30e52ab659cfe8c769b9d3

75e03232591b263a50523d7cfef4041db36caf01

/VMWsolutions/at2-vclient-032/cft/stress_netbounce_sequential.py

518e1c83ba827aa06f96eff5a194894f1e8f401f

no_license

https://github.com/adamkittel/src

aaf157062d069998a8d18841895e7362cf868ff9

11e3927bd990b885eba595346694de2d2601d5c9

refs/heads/master

""" This action will preform a Sequential netbounce stress test When run as a script, the following options/env variables apply: --mvip The managementVIP of the cluster SFMVIP env var --user The cluster admin username SFUSER env var --pass The cluster admin password SFPASS env var --emailTo List of addresses to send email to --clientIPs The IP addresses of the clients --clientUser The username for the client SFclientUser env var --clientPass The password for the client --waitTime The time to wait between nodes --addSSH Boolean to add SSH keys to nodes --iteration how many times to loop over the nodes, 0=forever """ import sys import time from optparse import OptionParser import lib.libsf as libsf from lib.libsf import mylog import logging import lib.sfdefaults as sfdefaults from lib.action_base import ActionBase import node_network_up_down import get_cluster_master import push_ssh_keys_to_node import wait_for_no_faults import check_client_health import check_cluster_health import count_available_drives import start_gc import wait_for_gc import get_active_nodes import send_email import clusterbscheck class StressNetbounceSequentialAction(ActionBase): class Events: """ Events that this action defines """ FAILURE = "FAILURE" EMAIL_SENT = "EMAIL_SENT" NODES_NOT_FOUND = "NODES_NOT_FOUND" CLIENT_NOT_HEALTHY = "CLIENT_NOT_HEALTHY" CLIENT_HEALTHY = "CLIENT_HEALTHY" CLUSTER_NOT_HEALTHY = "CLUSTER_NOT_HEALTHY" CLUSTER_HEALTHY = "CLUSTER_HEALTHY" FAULTS_FOUND = "FAULTS_FOUND" FAULTS_NOT_FOUND = "FAULTS_NOT_FOUND" ALL_NODES_FOUND = "ALL_NODES_FOUND" BEFORE_START_GC = "BEFORE_START_GC" GC_FINISHED = "GC_FINISHED" DRIVES_ADDED = "DRIVES_ADDED" DRIVES_NOT_ADDED = "DRIVES_NOT_ADDED" MASTER_NODE_NOT_FOUND = "MASTER_NODE_NOT_FOUND" PUSHED_SSH_KEYS = "PUSHED_SSH_KEYS" INTERFACE_DOWN = "INTERFACE_DOWN" INTERFACE_UP = "INTERFACE_UP" def __init__(self): super(self.__class__,self).__init__(self.__class__.Events) def fail(self, message, emailTo): mylog.error(message) send_email.Execute(emailTo=emailTo, emailSubject="Failed Stress Netbounce Sequential", emailBody=message) def ValidateArgs(self, args): libsf.ValidateArgs({"mvip" : libsf.IsValidIpv4Address, "username" : None, "password" : None, "waitTime" : libsf.IsInteger, "iteration" : libsf.IsInteger }, args) def Execute(self, mvip=sfdefaults.mvip, username=sfdefaults.username, password=sfdefaults.password, clientIPs=None, clientUser=sfdefaults.client_user, clientPass=sfdefaults.client_pass, waitTime=300, emailTo=None, addSSH=False, bsCheck=True, debug=False, iteration=1): self.ValidateArgs(locals()) if debug: mylog.console.setLevel(logging.DEBUG) #if the client ips is empty skip the check on the clients check_client = True if not clientIPs: mylog.info("Skipping health check on clients") check_client = False #get list of the nodes in the cluster mylog.step("Getting Active Nodes") node_list = get_active_nodes.Get(mvip=mvip, username=username, password=password) if(node_list == False): message = "Failied getting active nodes on " + mvip self.fail(message,emailTo) self._RaiseEvent(self.Events.NODES_NOT_FOUND) return False #if the addSSH key is true then try and add the SSH keys to the nodes if(addSSH == True): if push_ssh_keys_to_node.Execute(node_ips=node_list): mylog.info("Pushed SSH Keys to Nodes") self._RaiseEvent(self.Events.PUSHED_SSH_KEYS) else: message = "Failed pushing SSH keys to Node" self.fail(message, emailTo) return False else: mylog.info("Not pushing SSH Keys to Nodes") #iteration_count only used to display the current iteration iteration_count = 1 loop_forever = False if(iteration == 0): loop_forever = True mylog.warning("Looping Forever") #record the time of the start of the test start_time = time.time() while True: mylog.banner("Iteration Count: " + str(iteration_count)) #loop over each node for node in node_list: mylog.step("Current Node is: " + str(node)) #log the master node master_node = get_cluster_master.Get(mvip=mvip, username=username, password=password) if(master_node == False): message = "Failed to get the master node on " + mvip mylog.error(message) self._RaiseEvent(self.Events.MASTER_NODE_NOT_FOUND) else: mylog.info("Master Node: " + str(master_node[0])) #take down the network interface on each node mylog.step("Bouncing the 10G interface") if(node_network_up_down.Execute(nodeIP=node, username=username, password=password, interface="10g", action="down") == True): #mylog.info("Node: " + str(node) + " has been rebooted") #self._RaiseEvent(self.Events.NODE_REBOOTED) self._RaiseEvent(self.Events.INTERFACE_DOWN) else: message = "The Bond10G interface was not taken down on: " + node self.fail(message, emailTo) #self._RaiseEvent(self.Events.REBOOT_NODE_FAIL) return False #wait 1 minute mylog.step("Waiting 60 seconds") time.sleep(60) #try to bring the network interface back uo if(node_network_up_down.Execute(nodeIP=node, username=username, password=password, interface="10g", action="up") == True): self._RaiseEvent(self.Events.INTERFACE_UP) else: message = "The Bond10G interface was not brought back up on: " + node self.fail(message, emailTo) return False #wait another minute mylog.step("Waiting 60 seconds") time.sleep(60) mylog.step("Wait for faults to clear") #wait for faults to clear if(wait_for_no_faults.Execute(mvip) == True): #mylog.info("No faults found on " + mvip) self._RaiseEvent(self.Events.FAULTS_NOT_FOUND) else: message = "Faults found on " + mvip self.fail(message, emailTo) self._RaiseEvent(self.Events.FAULTS_FOUND) return False #make sure the cluster is healthy mylog.step("Check cluster health") if(check_cluster_health.Execute(mvip, since=start_time) == True): mylog.info("Cluster " + mvip + " is Healthy") self._RaiseEvent(self.Events.CLUSTER_HEALTHY) else: message = "Cluster " + mvip + " failed health check" self.fail(message, emailTo) self._RaiseEvent(self.Events.CLUSTER_NOT_HEALTHY) return False if bsCheck: mylog.step("Performing a Cluster BS Check") if clusterbscheck.Execute(mvip=mvip, username=username, password=password) == False: message = mvip + ": FAILED Cluster BS Check" self.fail(message, emailTo) return False #Check the health of the clients if(check_client == True): mylog.step("Check client health") if(check_client_health.Execute(client_ips=clientIPs, client_user=clientUser, client_pass=clientPass) == True): mylog.info("Client is Healthy") self._RaiseEvent(self.Events.CLIENT_HEALTHY) else: message = "Failed client health check" self.fail(message, emailTo) self._RaiseEvent(self.Events.CLIENT_NOT_HEALTHY) return False #check to see if there are available drives because the node took too long to reboot mylog.step("Looking for available drives") available_drives = count_available_drives.Get(mvip=mvip, username=username, password=password) if available_drives == -1: mylog.error("Unable to get a count of available drives") if available_drives > 0: #notify the user about this but continue the test send_email.Execute(emailTo=emailTo, emailSubject=mvip + ": There are available drives to add to the cluster: ") #add the drives back to the culster and wait for sync if(add_available_drives.Execute(mvip=mvip, username=username, password=password) == True): mylog.info("Available drives were added to the cluster") else: message = "Available drives were not added to the cluster" self.fail(message, emailTo) return False #check the health of the clients if(check_client == True): mylog.step("Check client health") if(check_client_health.Execute(client_ips=clientIPs, client_user=clientUser, client_pass=clientPass) == True): mylog.info("Client is Healthy") self._RaiseEvent(self.Events.CLIENT_HEALTHY) else: message = "Failed client health check" self.fail(message, emailTo) self._RaiseEvent(self.Events.CLIENT_NOT_HEALTHY) return False #wait before going to the next node if(waitTime > 0): mylog.step("Waiting for " + str(waitTime) + " seconds") time.sleep(waitTime) #end node for loop #start gc to keep the cluster from filling up, once per iteration mylog.step("Garbage Collection") self._RaiseEvent(self.Events.BEFORE_START_GC) if(start_gc.Execute(mvip=mvip) == True): pass else: message = "GC not started" self.fail(message, emailTo) return False #wait for gc to finish if(wait_for_gc.Execute(mvip=mvip) == True): mylog.info("GC finished") self._RaiseEvent(self.Events.GC_FINISHED) else: message = "GC failed to finish" self.fail(message, emailTo) self._RaiseEvent(self.Events.FAILURE) return False iteration_count += 1 #if iteration is not set to 0 from the start we will decrement iteration if(loop_forever == False): iteration -= 1 if(iteration <= 0): break end_time = time.time() delta_time = libsf.SecondsToElapsedStr(end_time - start_time) #calc stats iteration_count -= 1 num_of_nodes = len(node_list) time_per_iteration = (end_time - start_time) / iteration_count time_per_node = time_per_iteration / num_of_nodes time_per_iteration = libsf.SecondsToElapsedStr(time_per_iteration) time_per_node = libsf.SecondsToElapsedStr(time_per_node) emailBody = ("Number of Nodes:------ " + str(num_of_nodes) + "\nIteration Count:------ " + str(iteration_count) + "\nTime Per Iteration:--- " + time_per_iteration + "\nTime Per Node:-------- " + time_per_node + "\nTotal Time:----------- " + delta_time) send_email.Execute(emailTo=emailTo, emailSubject=mvip + ": Finished Stress Netbounce Sequential in " + delta_time, emailBody=emailBody) mylog.info("\tNumber of Nodes: " + str(num_of_nodes)) mylog.info("\tIteration Count: " + str(iteration_count)) mylog.info("\tTime Per Iteration: " + time_per_iteration) mylog.info("\tTime Per Node: " + time_per_node) mylog.info("\tTotal Time: " + delta_time) mylog.passed("The Stress Netbounce Sequential Test has passed") return True # Instantate the class and add its attributes to the module # This allows it to be executed simply as module_name.Execute libsf.PopulateActionModule(sys.modules[__name__]) if __name__ == '__main__': mylog.debug("Starting " + str(sys.argv)) parser = OptionParser(option_class=libsf.ListOption, description=libsf.GetFirstLine(sys.modules[__name__].__doc__)) parser.add_option("-m", "--mvip", type="string", dest="mvip", default=sfdefaults.mvip, help="the management IP of the cluster") parser.add_option("-u", "--user", type="string", dest="username", default=sfdefaults.username, help="the admin account for the cluster") parser.add_option("-p", "--pass", type="string", dest="password", default=sfdefaults.password, help="the admin password for the cluster") parser.add_option("-c", "--client_ips", action="list", dest="clientIPs", default=None, help="the IP addresses of the clients") parser.add_option("--wait_time", type="int", dest="waitTime", default=300, help="wait time after each node reboot") parser.add_option("--add_ssh", action="store_false", dest="addSSH", default=False, help="Add the SSH key to each node") parser.add_option("--email_to", action="list", dest="emailTo", default=None, help="the list of email addresses to send to") parser.add_option("--client_user", type="string", dest="clientUser", default=sfdefaults.client_user, help="the username for the clients [%default]") parser.add_option("--client_pass", type="string", dest="clientPass", default=sfdefaults.client_pass, help="the password for the clients [%default]") parser.add_option("--debug", action="store_true", dest="debug", default=False, help="display more verbose messages") parser.add_option("--bs_check", action="store_true", dest="bs_check", default=False, help="Do a cluster BS check") parser.add_option("--iteration", type="int", dest="iteration", default=1, help="how many times to loop over the nodes, 0=forever") (options, extra_args) = parser.parse_args() try: timer = libsf.ScriptTimer() if Execute(options.mvip, options.username, options.password, options.clientIPs, options.clientUser, options.clientPass, options.waitTime, options.emailTo, options.addSSH, options.bs_check, options.debug, options.iteration): sys.exit(0) else: sys.exit(1) except libsf.SfArgumentError as e: mylog.error("Invalid arguments - \n" + str(e)) sys.exit(1) except SystemExit: raise except KeyboardInterrupt: mylog.warning("Aborted by user") Abort() sys.exit(1) except: mylog.exception("Unhandled exception") sys.exit(1)

UTF-8

Python

py

stress_netbounce_sequential.py

Diego0103/PracticaIf

7abc1d3c891b81c0093e718f2e11acb3a35a20e8

124f395f3b82b6738d9b3906b6d9f7292a7a4a3c

/assignments/PruebasBasicas/src/exercise.py

d16ef71089bcc92334aac4695963dc0f08b81d67

no_license

https://github.com/Diego0103/PracticaIf

bb1c542289b6b4b78e9c1663c598b18f21313d32

d4a1016ff98e1b7f7e8117230cbd3c0fddc9de7b

refs/heads/main

def main(): #escribe tu código abajo de esta línea edad = int(input("Cual es tu edad?")) if edad>=18: print("Es mayor de edad") else: print("Es menor de edad") if __name__=='__main__': main()

UTF-8

Python

py

exercise.py

YINGHUOQRIN/shadowsocks-munager-1

a77d746e5577358abaaf491dd1708aa7b4471aeb

f58e62569840d1351e0d9611ded9c8f164801aff

/Munager/SpeedTestManager/__init__.py

d5002087fedb64a63344fc7a6d0a2a2e184f6a5f

no_license

https://github.com/YINGHUOQRIN/shadowsocks-munager-1

9b6f43d08fa2431826bb7ff05bbf8c3dc302fe90

d6e664bc041c41d5cd8dcad4a59265f3a6a8d84a

refs/heads/muapi

#!/usr/bin/python # -*- coding: UTF-8 -*- import logging import time import sys import os from .speedtest import Speedtest def speedtest_thread(): logging.info("Speedtest starting...You can't stop right now!") CTid = 0 speedtest_ct = Speedtest() speedtest_ct.get_servers() servers_list = [] for _, servers in sorted(speedtest_ct.servers.items()): for server in servers: if server['country'].find( 'China') != -1 and server['sponsor'].find('Telecom') != -1: servers_list.append(server) speedtest_ct.get_best_server(servers_list) results_ct = speedtest_ct.results CTPing = str(results_ct.server['latency']) + ' ms' speedtest_ct.download() CTDLSpeed = str( round( (results_ct.download / 1000 / 1000), 2)) + " Mbit/s" speedtest_ct.upload() CTUpSpeed = str( round( (results_ct.upload / 1000 / 1000), 2)) + " Mbit/s" CUid = 0 speedtest_cu = Speedtest() speedtest_cu.get_servers() servers_list = [] for _, servers in sorted(speedtest_cu.servers.items()): for server in servers: if server['country'].find( 'China') != -1 and server['sponsor'].find('Unicom') != -1: servers_list.append(server) speedtest_cu.get_best_server(servers_list) results_cu = speedtest_cu.results CUPing = str(results_cu.server['latency']) + ' ms' speedtest_cu.download() CUDLSpeed = str( round( (results_cu.download / 1000 / 1000), 2)) + " Mbit/s" speedtest_cu.upload() CUUpSpeed = str( round( (results_cu.upload / 1000 / 1000), 2)) + " Mbit/s" CMid = 0 speedtest_cm = Speedtest() speedtest_cm.get_servers() servers_list = [] for _, servers in sorted(speedtest_cm.servers.items()): for server in servers: if server['country'].find( 'China') != -1 and server['sponsor'].find('Mobile') != -1: servers_list.append(server) speedtest_cm.get_best_server(servers_list) results_cm = speedtest_cm.results CMPing = str(results_cm.server['latency']) + ' ms' speedtest_cm.download() CMDLSpeed = str( round( (results_cm.download / 1000 / 1000), 2)) + " Mbit/s" speedtest_cm.upload() CMUpSpeed = str( round( (results_cm.upload / 1000 / 1000), 2)) + " Mbit/s" result = [{'telecomping': CTPing, 'telecomeupload': CTUpSpeed, 'telecomedownload': CTDLSpeed, 'unicomping': CUPing, 'unicomupload': CUUpSpeed, 'unicomdownload': CUDLSpeed, 'cmccping': CMPing, 'cmccupload': CMUpSpeed, 'cmccdownload': CMDLSpeed}] return result if __name__ == "__main__": print(speedtest_thread())

UTF-8

Python

py

__init__.py

davidbernick/djangotest

ad95583e14ab2ba1b50cc4aacef9d1f84e60b9db

f6e829f75f7b293ca4e6a5b5253d8c34685bcd11

/setup.py

7c13592c6d05e2cec51f7561c4a77ccfaaf9cfe6

no_license

https://github.com/davidbernick/djangotest

15fce3f56095ab6b071670f65f44790b57247136

1b192afafe61cc97814e095666a3c1044bbc1e57

refs/heads/master

#!/usr/bin/env python from setuptools import setup setup( name='DjangoTest', version='1.0', description='DjangoTest', author='David Bernick', author_email='dbernick@gmail.com', install_requires=['django', 'django-guardian', 'boto', 'django-social-auth', 'django-bootstrap3', 'djangorestframework', 'markdown', 'django-filter', 'south' ], )

UTF-8

Python

py

setup.py

lucassilva-dev/codigo_Python

ebdf14078ded6f66fa4eea11aa3422ab5fd5f6bb

4491270a0e3754a959cd7582db51bb08583e00f3

/ex028.py

8ba1f67140f12aa45d62ea1ca93a3c1eb2c16f56

no_license

https://github.com/lucassilva-dev/codigo_Python

b6f1b24c08336fe121000b24204fd1cf2b728a8b

68fc9901cc8550085e1dee893d30634ac05b9c1d

refs/heads/master

import random sorte = [0, 1, 2, 3, 4, 5] resultado = random.choice(sorte) usuario = int(input('Eu pensei em um número entre 0 a 5.Qual é? ')) if usuario == resultado: print('Você acertou parábens') else: print('Você errou o número correto é {} !'.format(resultado))

UTF-8

Python

py

ex028.py

ahmadmoaaz2/Services

d34190aa107b2eccf2e2a36cbb3a97b001a333c1

171f2f676911283f250c7c9c71f85983cde452e5

/StorageService/food_and_water_readings.py

80b3423b19faa9ed4b1fc69b647a0ef9b04d805d

no_license

https://github.com/ahmadmoaaz2/Services

68824ecf763a8c6b59d475712fb2ff06f7f3e8f3

5b05c9ff1bcdfeda3ee118ea007b7b999e739b55

refs/heads/main

from sqlalchemy import Column, Integer, String from base import Base from datetime import datetime class FoodAndWaterReadings(Base): """ Food and Water Readings Class """ __tablename__ = "food_and_water_readings" id = Column(Integer, primary_key=True) name = Column(String(250), nullable=False) var1_name = Column(String(250)) var1_value = Column(String(250)) var2_name = Column(String(250)) var2_value = Column(String(250)) var3_name = Column(String(250)) var3_value = Column(String(250)) var4_name = Column(String(250)) var4_value = Column(String(250)) var5_name = Column(String(250)) var5_value = Column(String(250)) date_created = Column(String(100), nullable=False) def __init__(self, name, var1_name, var1_value, var2_name, var2_value, var3_name, var3_value, var4_name, var4_value, var5_name, var5_value): """ Initializes a blood pressure reading """ self.name = name self.var1_name = var1_name self.var1_value = var1_value self.var2_name = var2_name self.var2_value = var2_value self.var3_name = var3_name self.var3_value = var3_value self.var4_name = var4_name self.var4_value = var4_value self.var5_name = var5_name self.var5_value = var5_value self.date_created = datetime.now() def to_dict(self): """ Dictionary Representation of a blood pressure reading """ return { 'id': self.id, 'name': self.name, 'var1_name': self.var1_name, 'var1_value': self.var1_value, 'var2_name': self.var2_name, 'var2_value': self.var2_value, 'var3_name': self.var3_name, 'var3_value': self.var3_value, 'var4_name': self.var4_name, 'var4_value': self.var4_value, 'var5_name': self.var5_name, 'var5_value': self.var5_value, 'date_created': self.date_created }

UTF-8

Python

py

food_and_water_readings.py

ekagarwala/codingChallenges

49b408ca31f983a3545f40e36daee6ad0e0f8432

1df43e0bb58a2349f7196f455e69da7969e19e8e

/equality/equality.py

b341984396c94748427f395ff0de1191f97919b4

no_license

https://github.com/ekagarwala/codingChallenges

c4dfd4d60866fb90422d0f9a4b37db55a76eba23

d94d069e8d6e3dbb3daa7cbe3a78c0f19977bb1f

refs/heads/master

Python

import os import re os.chdir("e:\\repos\\codingChallenges\\data") message = '' possibilities = [] with open('../data/equality.txt', 'r') as inFile: inText = inFile.readlines() pat = re.compile("[a-z][A-Z]{3}[a-z][A-Z]{3}[a-z, \n]") for line in inText: match = re.search(pat, line) if match is not None: message += line[match.span()[0] + 4] possibilities.append(line[match.span()[0]:match.span()[1]]) print message

UTF-8

Python

py

equality.py

thiago-ximenes/curso-python

2fbf23c530922b0fd0cf4838dd4cd9a75f0e3890

15172fb42c923513108b09a32d7f6dc242d420b3

/pythonexercicios/ex090.py

230dd251a2caea795c2bc4c7434722a9e9fabed3

no_license

https://github.com/thiago-ximenes/curso-python

05fa3501972e878c4d0e8ffb07af5e86efdd6859

f0a1b98c42c9ff7329344a15460b20b577345b80

refs/heads/master

aluno = {} aluno['nome'] = str(input('Nome: ')).strip().title() aluno['média'] = float(input(f'Média de {aluno["nome"]}: ')) if aluno['média'] >= 7: aluno['situação'] = 'Aprovado' elif aluno['média'] < 5: aluno['situação'] = 'Reprovado' else: aluno['situação'] = 'Recuperação' print('-=' * 20) print() for k, v in aluno.items(): print(f'- {k}: {v}') print() print('-=' * 20)

UTF-8

Python

py

ex090.py

cyrus723/ml_python_micheal_bowles

d9b1b58543cbf52cd338fa5d9fddb8ef2fe094ac

1151021d25349882ee81b4164fe38033d72db2f3

/chapter2/code/listing2-5.py

4ca067d0d0a137fea825373b1378bdc33833e79f

no_license

https://github.com/cyrus723/ml_python_micheal_bowles

cd105e9c91fc0153a9b5a95138566a0142a89658

162df5676089788d6cd2e99a4bf865b79876df2f

refs/heads/master

import matplotlib.pyplot as plt import os import pandas as pd from pandas import DataFrame datafile = os.path.join(os.getcwd(), '../../datasets/sonar.all-data') rocks_v_mines = pd.read_csv(datafile, header=None, prefix='V') # Print head/tail of data frame print(rocks_v_mines.head()) print(rocks_v_mines.tail()) summary = rocks_v_mines.describe() print(summary)

UTF-8

Python

py

listing2-5.py

ksteph/cs61a-lab-reports

c0dcebb26885e4bde5e2d8b21420476209df8406

86e494f01e9af426fd4bda0167492f78009ec8db

/no_spark/lab_report.py

6d54b858bd85ce2464ae6870bbb20a0e250ce4b7

no_license

https://github.com/ksteph/cs61a-lab-reports

35ad3e719bac5e01c48868888b696565a37af322

7fc42823cdf344e79f7b72bcd54929054000834c

refs/heads/master

Python

import sys import numpy as np import datetime import os import matplotlib.pyplot as plt import matplotlib.patches as mpatches import data_reader import toolkit def usage_information(): info = 'Lab report generator for CS61a\n' info += 'Usage: lab_report.py <data_file_directory> <lab_name>' return info if len(sys.argv) < 3: print usage_information() print 'Generate report for {}'.format(sys.argv[2]) os.chdir('../report') if not os.path.exists('{}_report'.format(sys.argv[2])): os.makedirs('{}_report'.format(sys.argv[2])) os.chdir('./{}_report'.format(sys.argv[2])) ################ ### Get data ### ################ data = data_reader.SetupData(sys.argv[1], sys.argv[2]) data_set = data.data_set ################################## ### Initialize latex formatter ### ################################## formatter = toolkit.LatexFormatter(os.getcwd()+'/../template/', 'report.tex') formatter.set_param('name_map', data.name_map) formatter.set_param('LAB_NAME', sys.argv[2].upper()) ######################### ### Basic information ### ######################### NUM_STUDENT = data_set.get_element_count('student') formatter.set_param('NUM_STUDENT', NUM_STUDENT) NUM_QUESTION = data_set.get_element_count('specifier') formatter.set_param('NUM_QUESTION', NUM_QUESTION) NUM_SUBMISSION = data_set.count() formatter.set_param('NUM_SUBMISSION', NUM_SUBMISSION) NUM_DISTINCT_ANSWER = data_set.get_element_count('answer') formatter.set_param('NUM_DISTINCT_ANSWER', NUM_DISTINCT_ANSWER) NUM_WRONG_ANSWER = data_set.filter_by(lambda x: not x['result']).count() formatter.set_param('NUM_WRONG_ANSWER', NUM_WRONG_ANSWER) formatter.set_param('RATIO', '{:.2f}'.format(NUM_WRONG_ANSWER*100/float(NUM_SUBMISSION))) ###################################### ### Number of sessions per student ### ###################################### session_counter = [] tem_data = data_set.sort_by(lambda x: x['a_time']).group_by(lambda x: x['student']) for item in tem_data: # WARNING: This may throw an exception! session_cnt = toolkit.get_session_info(item[1]) if session_cnt == 0: continue while session_cnt > len(session_counter): session_counter.append(0) session_counter[session_cnt-1] += 1 # Print it out fig, ax = toolkit.prepare_plot(gridWidth=0) x = np.arange(len(session_counter)) width = 0.5 rects = plt.bar(x, session_counter, width, color='gray', alpha=0.7, edgecolor="gray") plt.ylabel('Number of students') plt.xticks(x + width/2., ["{:,} session(s)".format(item+1) for item in range(len(session_counter))]) toolkit.autolabel(rects, ax) plt.savefig('session_cnt.png') ######################################## ### Number of submissions per prompt ### ######################################## submission_counter = [0] * NUM_QUESTION for prompt in range(NUM_QUESTION): submission_counter[prompt] = data_set.filter_by(lambda x: x['specifier']==prompt).count() # Print it out width = 0.5 fig, ax = toolkit.prepare_plot(gridWidth=0) x = np.arange(NUM_QUESTION) rects = plt.bar(x, submission_counter, width, color='gray', alpha=0.7, edgecolor="gray") plt.ylabel('Number of submissions') plt.xticks(x + width/2., [item for item in range(NUM_QUESTION)]) plt.xlabel('Prompt ID') toolkit.autolabel(rects, ax, 2) plt.savefig('submission_per_prompt.png') ################################################# ### Number of unique wrong answers per prompt ### ################################################# unique_answer_counter = [0] * NUM_QUESTION for prompt in range(NUM_QUESTION): unique_answer_counter[prompt] = data_set.filter_by(lambda x: x['specifier']==prompt and not x['result']).get_element_count('answer') # Print it out width = 0.5 fig, ax = toolkit.prepare_plot(gridWidth=0) x = np.arange(NUM_QUESTION) rects = plt.bar(x, unique_answer_counter, width, color='gray', alpha=0.7, edgecolor="gray") plt.ylabel('Number of unique answers') plt.xticks(x + width/2., [item for item in range(NUM_QUESTION)]) plt.xlabel('Prompt ID') toolkit.autolabel(rects, ax, 2) plt.savefig('unique_answer_per_prompt.png') ##################################### ### Number of attempts per prompt ### ##################################### attempt_counter = [[0 for i in xrange(10)] for j in xrange(NUM_QUESTION)] for prompt in range(NUM_QUESTION): tem_data = data_set.filter_by(lambda x: x['specifier']==prompt) tem_data = tem_data.group_by(lambda x: x['student']).map(lambda x: len(x[1])) for item in tem_data: attempt_counter[prompt][np.min([item-1, 9])] += 1 attempt_counter = np.array(attempt_counter).T # print result ind = np.arange(NUM_QUESTION) width = 0.5 fig, ax = toolkit.prepare_plot(gridWidth=0) tem_bottom = [0]*NUM_QUESTION color = plt.cm.Blues(np.linspace(0, 1, 10)) p = [] for i in range(10): bar = plt.bar(ind, attempt_counter[i], width, color=color[i], bottom=tem_bottom, edgecolor=color[i]) p.append(bar) for j in range(NUM_QUESTION): tem_bottom[j] += attempt_counter[i][j] plt.ylabel('Number of students') plt.xticks(ind+width/2., [x for x in range(NUM_QUESTION)]) plt.xlabel('Prompt ID') plt.gcf().subplots_adjust(right=0.8) plt.legend(p, (x+1 for x in range(10)), loc='center left', bbox_to_anchor=(1, 0.5)) plt.savefig('attempt_cnt.png') formatter.set_param('attempt_counter', np.array(attempt_counter).T) ######################## ### Time information ### ######################## selected_data = data_set.sort_by(lambda x: x['a_time']) start_time = selected_data[0]['a_time'] end_time = selected_data[-1]['a_time'] tem_lmt = start_time buckets = [] while tem_lmt < end_time: tem_lmt += datetime.timedelta(0, 3600) buckets.append(tem_lmt) time_info_counter = [[0 for j in range(len(buckets)+1)] for i in range(NUM_QUESTION)] for prompt in range(NUM_QUESTION): tem_data = data_set.filter_by(lambda x: x['specifier']==prompt) for item in tem_data.map(lambda x: x['a_time']): for index in range(len(buckets)): if item < buckets[index]: break if index==len(buckets)+1 and item>buckets[idnex]: index += 1 time_info_counter[prompt][index] += 1 # Print it out plot_data = [np.array([0]*(len(buckets)+1))] for item in time_info_counter: plot_data.append(plot_data[-1]+np.array(item)) x_ax = np.arange(len(buckets)+1) fig, ax = toolkit.prepare_plot(gridWidth=0.5, figsize=(10.5, 8)) c_patches = [] for i in range(NUM_QUESTION): plt.fill_between(x_ax, plot_data[i+1], plot_data[i], facecolor=plt.cm.rainbow_r(0.1*i), label='Prompt {}'.format(i)) c_patches.append(mpatches.Patch(color=plt.cm.rainbow_r(0.1*i), label=data.name_map[i])) # plt.legend(handles=c_patches) plt.legend() plt.xticks(x_ax[1::2], [(time-datetime.timedelta(0, 4200)).strftime('%m-%d %H:%M') for time in buckets[0::2]], rotation='40', ha='right') plt.xlabel("Timestamp (mm-dd hh:mm)") plt.ylabel("Number of submissions") plt.savefig('time_info.png') ######################################################### ### Most common wrong answers and first wrong answers ### ######################################################### wrong_answers_counter = [[] for i in range(NUM_QUESTION)] first_answers_counter = [[] for i in range(NUM_QUESTION)] tem_data_set = data_set.filter_by(lambda x: not x['result']) for prompt in range(NUM_QUESTION): selected_data = tem_data_set.filter_by(lambda x: x['specifier']==prompt) total_num = selected_data.count() selected_data = selected_data.group_by(lambda x: x['answer']).map(lambda x: (x[0], len(x[1]), len(x[1])/float(total_num))) selected_data = selected_data.sort_by(lambda x: -x[1]) if selected_data.count() > 10: wrong_answers_counter[prompt] = selected_data[:10] else: wrong_answers_counter[prompt] = selected_data selected_data = tem_data_set.filter_by(lambda x: x['specifier']==prompt).sort_by(lambda x: x['a_time']).group_by(lambda x: x['student']).map(lambda x: x[1][0]) total_num = selected_data.count() selected_data = selected_data.group_by(lambda x: x['answer']).map(lambda x: (x[0], len(x[1]), len(x[1])/float(total_num))) selected_data = selected_data.sort_by(lambda x: -x[1]) if selected_data.count() > 10: first_answers_counter[prompt] = selected_data[:10] else: first_answers_counter[prompt] = selected_data formatter.set_param('wrong_answers_counter', wrong_answers_counter) formatter.set_param('first_answers_counter', first_answers_counter) ################################# ### Response time information ### ################################# RESPONSE_BUCKETS = [60, 120, 300, 600] response_time_counter = [[0 for i in range(len(RESPONSE_BUCKETS)+1)] for j in range(NUM_QUESTION)] for prompt in range(NUM_QUESTION): selected_data = data_set.filter_by(lambda x: x['specifier']==prompt) selected_data = selected_data.sort_by(lambda x: x['a_time']).group_by(lambda x: x['student']) selected_data = selected_data.map(lambda x: toolkit.get_time_information(x[1]).total_seconds()) for item in selected_data: for index in range(len(RESPONSE_BUCKETS)): if item < RESPONSE_BUCKETS[index]: break if index == 3 and item > RESPONSE_BUCKETS[3]: index = 4 response_time_counter[prompt][index] += 1 ind = np.arange(len(RESPONSE_BUCKETS)+1) width = 1 fig, ax = toolkit.prepare_plot(gridWidth=0) rects = plt.bar(ind, response_time_counter[prompt], width, color='gray', edgecolor='gray') plt.ylabel('#Students') plt.xlabel('Time point (min)') plt.xticks([loc+width for loc in ind], [t/60 for t in RESPONSE_BUCKETS]) toolkit.autolabel(rects, ax) plt.savefig('response_time_{}'.format(prompt)) ######################### ### Render the report ### ######################### formatter.render('{}_report.tex'.format(sys.argv[2]))

UTF-8

Python

py

lab_report.py

elishevasheinin/DNA-command-prompt

fe6e4b0a6e0c7484baf88190eb41a602153a0cf0

ee8da0c94006f8cbf96716bdbb15c7d7ef07573c

/Analysis/__init__.py

20c28462fbfe498cfc3fdefb15ddfafb21860f8e

no_license

https://github.com/elishevasheinin/DNA-command-prompt

6d2a0e7ebc139a0bb5cab444c3e53421dc6bde3a

ed336e2dc409e99f1ae825da039e2cb495a7a7ec

refs/heads/master

from .count import Count from .find import Find from .find_all import FindAll from .len import Len

UTF-8

Python

py

__init__.py

kkraoj/wildfire-risk-treehacks

85d7eef52218a2d0c4b38990448d55ed6b90146f

d0419a9e083073b052faa78a17566f5e4e77f343

/save_map_as_tif_p27.py

62131c0b7464ea6d2a3a19e66c5fb7f00105618f

no_license

https://github.com/kkraoj/wildfire-risk-treehacks

e9641ea7aedeb3294bcf59486849aff6ccde1e3e

a99916d7454535ad9243b9f78e378914fa5b68d3

refs/heads/master

# -*- coding: utf-8 -*- """ Created on Fri Sep 13 07:14:21 2019 @author: kkrao """ import numpy as np import pandas as pd from osgeo import gdal from osgeo import gdal_array from osgeo import osr import matplotlib.pylab as plt from datetime import datetime for MoY in range(7, 8): date = '2018-%02d-01'%(MoY) print('[INFO] Making lfmc tif for %s at %s'%(date,datetime.now().strftime("%H:%M:%S"))) #fname = 'map/fmc_map_%s'%date fname = r'D:\Krishna\projects\vwc_from_radar\data\map\dynamic_maps\fmc_map_%s'%date # latlon = pd.read_csv(fname+'.csv', index_col = 0) df = pd.read_pickle(fname) # mask = pd.read_csv(r'D:\Krishna\projects\vwc_from_radar\data\map\mask_classified_2018_07_01.csv', index_col = 0) # df = pd.merge(latlon,mask, on=['latitude','longitude']) # df.loc[df['mask']==1,'pred_fmc'] = -9999 df['lat_index'] = df.latitude.rank(method = 'dense', ascending = False).astype(int)-1 df['lon_index'] = df.longitude.rank(method = 'dense', ascending = True).astype(int)-1 u_lons = np.sort(df.longitude.unique()) u_lats = np.sort(df.latitude.unique())[::-1] xx, yy = np.meshgrid(u_lons,u_lats) zz = xx.copy() zz[:] = -9999 zz[df.lat_index.values,df.lon_index.values] = df.pred_fmc.values array = zz.astype(int) fig, ax = plt.subplots(figsize = (2,2)) ax.imshow(array,vmin = 50, vmax = 200) ax.set_title(date) plt.show() lat = yy lon = xx # For each pixel I know it's latitude and longitude. # As you'll see below you only really need the coordinates of # one corner, and the resolution of the file. xmin,ymin,xmax,ymax = [lon.min(),lat.min(),lon.max(),lat.max()] nrows,ncols = np.shape(array) xres = (xmax-xmin)/float(ncols) yres = (ymax-ymin)/float(nrows) geotransform=(xmin,xres,0,ymax,0, -yres) # That's (top left x, w-e pixel resolution, rotation (0 if North is up), # top left y, rotation (0 if North is up), n-s pixel resolution) # I don't know why rotation is in twice??? output_raster = gdal.GetDriverByName('GTiff').Create(r'D:\Krishna\projects\vwc_from_radar\data\map\dynamic_maps\lfmc_map_%s.tif'%date,ncols, nrows, 1 ,gdal.GDT_Float32) # Open the file output_raster.SetGeoTransform(geotransform) # Specify its coordinates srs = osr.SpatialReference() # Establish its coordinate encoding srs.ImportFromEPSG(4326) # This one specifies WGS84 lat long. # Anyone know how to specify the # IAU2000:49900 Mars encoding? output_raster.SetProjection( srs.ExportToWkt() ) # Exports the coordinate system # to the file output_raster.GetRasterBand(1).WriteArray(array) # Writes my array to the raster output_raster.FlushCache() output_raster = None

UTF-8

Python

py

save_map_as_tif_p27.py

kennedyCzar/AlphabetSoup-Using-Django

0f765c0e055a23b6951d9a09ff734b4e59361867

a8a879c5c2df2ca20c184ca9fb0c305a1d036110

/SCRIPT/BST_SecondlargeVal.py

c4a885feff24de17f7d3840039edbed9732d6efd

permissive

https://github.com/kennedyCzar/AlphabetSoup-Using-Django

f749ba065f5c3fbed734d505a4169ba72c273980

4503cbfe9d0c9f9d8bfa1ae03c2da76537781e52

refs/heads/master

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Thu Jun 20 18:44:33 2019 @author: kenneth """ ''' Given the root to a binary search tree, find the second largest node in the tree. ''' def largestNode(rootNode): currentNode = rootNode while currentNode: if not currentNode.right: return currentNode.value else: currentNode = currentNode.right def secondLargetNode(rootNode): if (rootNode is None or (rootNode.left is None and rootNode.right)) : return else: currentNode = rootNode while currentNode: if largestNode.left and not largestNode.right: return largestNode(largestNode.left) if currentNode.right and not currentNode.right.left and not currentNode.right.left: return currentNode.value currentNode = currentNode.right

UTF-8

Python

py

BST_SecondlargeVal.py

easync/ao-api-samples

ba03ef5ccc16768534d23fa234886c4751afe55f

a15b7fa8f91badc1a25a3267e9ac112f050d321a

/python/place_an_order.py

9969a40caf4d2221e420d4ad51e7e7e593023fad

no_license

https://github.com/easync/ao-api-samples

15c15bb79481390549918c5dbd073bacb13aaea7

096a5e5eb971e0af59bd6345d4146b84ba6de660

refs/heads/master

import requests import json true = True false = False API_TOKEN = '00000000-0000-0000-0000-000000000000'; #SEE https://app.easync.io/api for details RETAILER = 'amazon'; PRODUCT_ID = 'B01K7C0CSA'; # Amazon US # PRODUCT_ID = 'B01BRC1ZYE'; # Amazon DE # PRODUCT_ID = 'B00V6C5Z0Q'; # Amazon UK # PRODUCT_ID = 'B010S9M3L6'; # Amazon ES # PRODUCT_ID = 'B019HC54WU'; # Amazon FR # PRODUCT_ID = 'B019HC54WU'; # Amazon CA # PRODUCT_ID = 'B007PNGRPC'; # Amazon IT MAX_PRICE = 15000; RETAILER_CREDENTIALS = { "email": 'user@gmail.com', "password": '123456' } BILLING_ADDRESS = { "first_name": "John", "last_name": "Smith", "address_line1": "14 Bus St.", "address_line2": "", "zip_code": "123456", "city": "Atlanta", "state": "GA", "country": "US", "phone_number": "1234567890" } SHIPPING_ADDRESS = { "first_name": "Eric", "last_name": "Walter", "address_line1": "18 Ellie St.", "address_line2": "", "zip_code": "070065", "city": "Sacramento", "state": "CA", "country": "US", "phone_number": "1234567890" }; PAYMENT_METHOD = { "expiration_month": 9, "expiration_year": 9999, "name_on_card": "Jack Sparrow", "number": "0000000000000000", "security_code": "555", "use_gift": true }; ORDER = { "retailer": RETAILER, "retailer_credentials": RETAILER_CREDENTIALS, "products": [ { "product_id": PRODUCT_ID, "quantity": 1, "seller_selection_criteria": { "condition_in": [ "New" ], "handling_days_max": 5, "max_item_price": MAX_PRICE, "prime": true } } ], "shipping_address": SHIPPING_ADDRESS, "shipping_method": "free", "billing_address": BILLING_ADDRESS, "payment_method": PAYMENT_METHOD, "is_gift": true, "gift_message": "Thank you so much!", "max_price": MAX_PRICE, } print requests.post("https://core.easync.io/api/v1/orders", auth=(API_TOKEN, ''), json=ORDER).content;

UTF-8

Python

py

place_an_order.py

grzesiu/hackerrank

5e58b4bb74defd51f95ef601f48bf3577515fa7a

757274035404da163ff110f9da964094abe38657

/algorithms/strings/special-palindrome-again.py

02aaee752593d1768d777a1ed60cee5ab3fe55ae

no_license

https://github.com/grzesiu/hackerrank

4ecc8c1df85372bfbd68e30caa3c56e130764e75

a1a88a0cae50a0045e7b90c4582d02f9172509ef

refs/heads/master

def get_counts(n, s): counts = [[s[0], 1]] for i in range(1, n): if counts[-1][0] == s[i]: counts[-1][1] += 1 else: counts.append([s[i], 1]) return counts def count_same(counts): sums = [0] for i in range(1, max(list(zip(*counts))[1]) + 1): sums.append(i + sums[-1]) acc = 0 for _, count in counts: acc += sums[count] return acc def count_different_middle(counts): acc = 0 for i in range(1, len(counts) - 1): if counts[i][1] == 1 and counts[i - 1][0] == counts[i + 1][0]: acc += min(counts[i - 1][1], counts[i + 1][1]) return acc if __name__ == '__main__': n = int(input()) s = input() counts = get_counts(n, s) total = count_same(counts) + count_different_middle(counts) print(total)

UTF-8

Python

py

special-palindrome-again.py

brennv/graphql-pynamodb

2ccaa4e4202e493ab54ef49f1c1a7e07720146f3

0b4d5ddb14925ed9e0d051be89410936d7e0ef73

/graphene_pynamodb/relationships.py

cca280dcf7aced67fe49bab7c6c8d9ee643bd127

no_license

https://github.com/brennv/graphql-pynamodb

7d356d828bf1cf68573232d8cf2ab97990885e74

c9a2827aaa84950ee15a51a5cade3570634fa6fa

refs/heads/master

from pynamodb.attributes import Attribute, NumberAttribute from pynamodb.constants import STRING, STRING_SET from pynamodb.models import Model from six import string_types from wrapt import ObjectProxy class RelationshipResult(ObjectProxy): _key = None _key_name = '' _model = None def __init__(self, key_name, key, obj): super(RelationshipResult, self).__init__(obj) self._key = key self._key_name = key_name self._model = obj def __getattr__(self, name): # If we are being to lookup '__wrapped__' then the # '__init__()' method cannot have been called. if name == '__wrapped__': raise ValueError('wrapper has not been initialised') if name.startswith('_'): return getattr(self.__wrapped__, name) if name == self._key_name: return self._key if isinstance(self.__wrapped__, type) and issubclass(self.__wrapped__, Model): self.__wrapped__ = self.__wrapped__.get(self._key) return getattr(self.__wrapped__, name) def __eq__(self, other): # Shallow compare by id for relationship purposes if isinstance(self.__model__, type) and issubclass(self.__model__, Model): return isinstance(other, self.__model__) and self.__key__ == getattr(other, self.__key_name__) else: return (self.__model__.__class__ == other.__class__) and self.__key__ == getattr(other, self.__key_name__) def __ne__(self, other): return self.__model__ != other class Relationship(Attribute): _models = None @classmethod def sub_classes(cls, klass): return klass.__subclasses__() + [g for s in klass.__subclasses__() for g in Relationship.sub_classes(s)] @classmethod def get_model(cls, model_name): # Resolve a model name into a model class by looking in all Model subclasses if not Relationship._models: Relationship._models = Relationship.sub_classes(Model) return next((model for model in Relationship._models if model.__name__ == model_name), None) def __init__(self, model, hash_key="id", lazy=True, **args): if not isinstance(model, string_types) and not issubclass(model, Model): raise TypeError("Expected PynamoDB Model argument, got: %s " % model.__class__.__name__) Attribute.__init__(self, **args) self._model = model self.hash_key_name = hash_key self._lazy = lazy @property def model(self): if isinstance(self._model, string_types): self._model = Relationship.get_model(self._model) return self._model class OneToOne(Relationship): attr_type = STRING def serialize(self, model): return str(getattr(model, self.hash_key_name)) def deserialize(self, hash_key): if isinstance(getattr(self.model, self.hash_key_name), NumberAttribute): hash_key = int(hash_key) try: if self._lazy: return RelationshipResult(self.hash_key_name, hash_key, self.model) else: return self.model.get(hash_key) except self.model.DoesNotExist: return None class OneToMany(Relationship): attr_type = STRING_SET def serialize(self, models): return [str(getattr(model, self.hash_key_name)) for model in models] def deserialize(self, hash_keys): if isinstance(getattr(self.model, self.hash_key_name), NumberAttribute): hash_keys = map(int, hash_keys) try: if self._lazy: return [RelationshipResult(self.hash_key_name, hash_key, self.model) for hash_key in hash_keys] else: return self.model.get_batch(hash_keys) except self.model.DoesNotExist: return None

UTF-8

Python

py

relationships.py

kebitmatf/LearnTF

81c2ac7f8ce1bbc3bcefaf95fc9b3e54c290fb35

b77dc74e17f9f8e6cdb49ad329b8b17e6c4334f9

/art_test.py

69a9ff61826b71c03bd74ccb10c3f3a5b95f07c7

no_license

https://github.com/kebitmatf/LearnTF

e58bdccc07e4b049268381d0215ad68875551e7d

d400da5e0bb9e215521b6722b38f64824293392a

refs/heads/master

# -*- coding: utf-8 -*- """ Created on Fri Jul 21 13:47:11 2017 @author: SEA """ import os import tensorflow as tf import scipy.io as io import scipy.misc as misc import matplotlib.pyplot as plt import numpy as np import time path_vggmodel = 'imagenet-vgg-verydeep-19.mat' path_style = 'images/guernica.jpg' path_content = 'images/hongkong.jpg' path_out = 'test_output' imag_height = 600 imag_width = 800 color_channels = 3 mean_value = np.array([123.68, 116.779, 103.939]).reshape((1,1,1,3)) alpha = 100 beta = 5 noise_ratio = 0.6 def imag_load (path): imag = misc.imread(path) if imag.shape[0:2] != (imag_height, imag_width): imag = misc.imresize(imag, (imag_height, imag_width), 'bilinear') # plt.imshow(imag) # plt.show imag = imag.reshape((1,)+imag.shape) - mean_value return imag def imag_save(path, name, imag): file_name = path+'/'+name imag = imag + mean_value imag = imag.reshape(imag[0]) imag = np.clip(imag, 0, 255) # plt.imshow(imag) # plt.show misc.imsave(file_name, imag) def imag_noise(imag, noise_ratio): noise = np.random.uniform(-20, 20, (1, imag_height, imag_width, color_channels)) imag = noise * noise_ratio + imag * (1-noise_ratio) imag = np.clip(imag, 0, 255) # plt.imshow(imag[0]) # plt.show return imag # Get params in VGG and modify the model maxpool -> avgpool def vgg_model(path): """ 0 is conv1_1 (3, 3, 3, 64) 1 is relu 2 is conv1_2 (3, 3, 64, 64) 3 is relu 4 is maxpool 5 is conv2_1 (3, 3, 64, 128) 6 is relu 7 is conv2_2 (3, 3, 128, 128) 8 is relu 9 is maxpool 10 is conv3_1 (3, 3, 128, 256) 11 is relu 12 is conv3_2 (3, 3, 256, 256) 13 is relu 14 is conv3_3 (3, 3, 256, 256) 15 is relu 16 is conv3_4 (3, 3, 256, 256) 17 is relu 18 is maxpool 19 is conv4_1 (3, 3, 256, 512) 20 is relu 21 is conv4_2 (3, 3, 512, 512) 22 is relu 23 is conv4_3 (3, 3, 512, 512) 24 is relu 25 is conv4_4 (3, 3, 512, 512) 26 is relu 27 is maxpool 28 is conv5_1 (3, 3, 512, 512) 29 is relu 30 is conv5_2 (3, 3, 512, 512) 31 is relu 32 is conv5_3 (3, 3, 512, 512) 33 is relu 34 is conv5_4 (3, 3, 512, 512) 35 is relu 36 is maxpool 37 is fullyconnected (7, 7, 512, 4096) 38 is relu 39 is fullyconnected (1, 1, 4096, 4096) 40 is relu 41 is fullyconnected (1, 1, 4096, 1000) 42 is softmax """ vgg = io.loadmat(path) vgg_layers = vgg['layers'] def _weight(layer, expected_layer_name): W = vgg_layers[0][layer][0][0][0][0][0] b = vgg_layers[0][layer][0][0][0][0][1] layer_name = vgg_layers[0][layer][0][0][-2] assert layer_name == expected_layer_name return W, b def _relu(layer): return tf.nn.relu(layer) def _conv2d(prev_layer, layer, layer_name): W, b = _weight(layer, layer_name) b = b.reshape(b.size) W = tf.constant(W) b = tf.constant(b) layer = tf.nn.conv2d(input = prev_layer, filter = W, strides = [1,1,1,1], padding= 'SAME') + b return layer def _avgpool(layer): return tf.nn.avg_pool(layer, ksize = [1,2,2,1], strides = [1,1,1,1], padding = 'SAME') # Build graph model graph ={} graph['input'] = tf.Variable(np.zeros((1, imag_height, imag_width, color_channels), dtype = 'float32')) graph['conv1_1'] = _conv2d(graph['input'], 0, 'conv1_1') graph['relu1_1'] = _relu(graph['conv1_1']) graph['conv1_2'] = _conv2d(graph['relu1_1'], 2, 'conv1_2') graph['relu1_2'] = _relu(graph['conv1_2']) graph['avgpool1'] = _avgpool(graph['relu1_2']) graph['conv2_1'] = _conv2d(graph['avgpool1'], 5, 'conv2_1') graph['relu2_1'] = _relu(graph['conv2_1']) graph['conv2_2'] = _conv2d(graph['relu2_1'], 7, 'conv2_2') graph['relu2_2'] = _relu(graph['conv2_2']) graph['avgpool2'] = _avgpool(graph['relu2_2']) graph['conv3_1'] = _conv2d(graph['avgpool2'], 10, 'conv3_1') graph['relu3_1'] = _relu(graph['conv3_1']) graph['conv3_2'] = _conv2d(graph['relu3_1'], 12, 'conv3_2') graph['relu3_2'] = _relu(graph['conv3_2']) graph['conv3_3'] = _conv2d(graph['relu3_2'], 14, 'conv3_3') graph['relu3_3'] = _relu(graph['conv3_3']) graph['conv3_4'] = _conv2d(graph['relu3_3'], 16, 'conv3_4') graph['relu3_4'] = _relu(graph['conv3_4']) graph['avgpool3'] = _avgpool(graph['relu3_4']) graph['conv4_1'] = _conv2d(graph['avgpool3'], 19, 'conv4_1') graph['relu4_1'] = _relu(graph['conv4_1']) graph['conv4_2'] = _conv2d(graph['relu4_1'], 21, 'conv4_2') graph['relu4_2'] = _relu(graph['conv4_2']) graph['conv4_3'] = _conv2d(graph['relu4_2'], 23, 'conv4_3') graph['relu4_3'] = _relu(graph['conv4_3']) graph['conv4_4'] = _conv2d(graph['relu4_3'], 25, 'conv4_4') graph['relu4_4'] = _relu(graph['conv4_4']) graph['avgpool4'] = _avgpool(graph['relu4_4']) graph['conv5_1'] = _conv2d(graph['avgpool4'], 28, 'conv5_1') graph['relu5_1'] = _relu(graph['conv5_1']) graph['conv5_2'] = _conv2d(graph['relu5_1'], 30, 'conv5_2') graph['relu5_2'] = _relu(graph['conv5_2']) graph['conv5_3'] = _conv2d(graph['relu5_2'], 32, 'conv5_3') graph['relu5_3'] = _relu(graph['conv5_3']) graph['conv5_4'] = _conv2d(graph['relu5_3'], 34, 'conv5_4') graph['relu5_4'] = _relu(graph['conv5_4']) graph['avgpool5'] = _avgpool(graph['relu5_4']) return graph def content_loss_func(sess, model): p = sess.run(model['conv4_2']) x = model['conv4_2'] N = p.shape[3] # No. filters M = p.shape[1] * p.shape[2] # No. feature map = filter size loss = 1/(4*N*M) * tf.reduce_mean(tf.pow(x - p, 2)) return loss def style_loss_func(sess, model): def gram_matrix (F, N, M): # Reshape to NxM matrix of F F = tf.reshape(F, (N, M)) G = tf.matmul(tf.transpose(F), F) return G def _style_loss(a, x): N = a.shape[3] M = a.shape[1] * a.shape[2] A = gram_matrix(a, N, M) G = gram_matrix(x, N, M) loss = 1/(4 * N**2 * M**2) * tf.reduce_mean(tf.pow(G - A, 2)) return loss layer_filters = [ ('conv1_1', 0.5), ('conv2_1', 1.0), ('conv3_1', 2.0), ('conv4_1', 3.0), ('conv5_1', 4.0) ] E = [_style_loss(sess.run(model[layer_name]), model[layer_name]) for layer_name, _ in layer_filters] W = [w for _, w in layer_filters] L = sum(W[l] * E[l] for l in range(len(layer_filters))) return L with tf.device('/cpu:0'): # Start calculation imag_content = imag_load(path_content) imag_style = imag_load(path_style) imag_input = imag_noise(imag_content, noise_ratio) graph = vgg_model(path_vggmodel) # tf.InteractiveSession is same with tf.Session but not need to call with tf.Session. # It wokrs like 'evaluation' functions sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) # Initial all variables # Content loss sess.run(graph['input'].assign(imag_content)) content_loss = content_loss_func(sess, graph) # Style loss sess.run(graph['input'].assign(imag_style)) style_loss = style_loss_func(sess, graph) # Total loss loss_total = alpha * content_loss + beta * style_loss optimizer = tf.train.AdamOptimizer(learning_rate = 2.0).minimize(loss_total) start_time = time.time() if __name__ == '__main__': with tf.Session() as sess: sess.run(tf.global_variables_initializer()) sess.run(graph['input'].assign(imag_input)) if not os.path.exists(path_out): os.mkdir(path_out) iteration = 2 for i in range(0, iteration): sess.run(optimizer) print(i) if i % 2 == 0: imag_mixed = sess.run(graph['input']) file_name = 'train {}.jpg'.format(i) imag_save(path_out, file_name, imag_mixed ) end_time = time.time() print("Time usage: {0:>6.2}".format(end_time-start_time))

UTF-8

Python

py

art_test.py

matbur/advent-of-code

89ee762e13bfab81bae28ead8a3b04885237af25

b2cb4a420350f2bf4e0ef8b8c84ba099f52213b5

/2017/03/part1.py

03fe6e847e930454f515c0532edb27042c451bea

permissive

https://github.com/matbur/advent-of-code

67fbbf55d1fec636994fdf7b98fd9fb491a93999

f4f1fbcd3d733c057b0097c163a0d648a45cc6cc

refs/heads/master

MIT

Python

#!/usr/bin/env python3 def foo(N): d = [0, 0, 0, 0] s = 1 for i in range(2, N + 1): n = i // 2 d_i = (i - 2) % 4 sn = s + n if sn == N: d[d_i] += n break elif sn < N: d[d_i] += n s += n else: d[d_i] += N - s break return d[0] - d[2], d[1] - d[3] def foo2(n): x, y = foo(n) return abs(x) + abs(y) if __name__ == "__main__": print("min") for i in (1, 12, 23, 1024): print(i, foo2(i)) print("full", foo2(265149))

UTF-8

Python

py

part1.py

akostyuk/flask-dbmigrate

809cc3015f932dd75c51aa0fa8abf2a3f406a167

1c7a886a068f433d1fe9c0b76c6f77976098d5e1

/tests.py

3a62f2b9323be40396da4e1ae1e4dcf4efcd3251

permissive

https://github.com/akostyuk/flask-dbmigrate

e29e651497d225cedcfb094111ed5e4631fc4213

e7461a4e066420f78161316d49eb4099955505b0

refs/heads/master

import os import re import sys import unittest import logging from shutil import rmtree from StringIO import StringIO from flask import Flask from flask.ext.script import Command, Manager from flask.ext.sqlalchemy import SQLAlchemy from sqlalchemy.engine.reflection import Inspector from flask_dbmigrate import DBMigrate, ImproperlyConfigured from flask_dbmigrate import manager as dbmanager def rel(path): return os.path.join(os.path.abspath(os.path.dirname(__file__)), path) def make_test_model(db): class Test(db.Model): __tablename__ = 'test' id = db.Column('test_id', db.Integer, primary_key=True) column1 = db.Column(db.String(60)) def __init__(self, column1): self.column1 = column1 return Test def with_database(test_method): def wrapper(self): self.dbmigrate.init() self.dbmigrate._upgrade() test_method(self) self.dbmigrate._drop() return wrapper def with_database_changes(test_method): def wrapper(self): self.dbmigrate.init() self.dbmigrate._upgrade() self.app.db = SQLAlchemy(self.app) class Test(self.app.db.Model): __tablename__ = 'test' id = self.app.db.Column('test_id', self.app.db.Integer, primary_key=True) column1 = self.app.db.Column(self.app.db.String(60)) column2 = self.app.db.Column(self.app.db.String(60)) def __init__(self, column1): self.column1 = column1 test_method(self) self.dbmigrate._drop() return wrapper class TestConfig(object): DEBUG = True SQLALCHEMY_DATABASE_URI = 'sqlite:///' + rel('test.sqlite3') # SQLALCHEMY_DATABASE_URI = 'sqlite://' SQLALCHEMY_MIGRATE_REPO = rel('migrations') class TestCommand(Command): def run(self): print('test ok') class DBMigrateInitTestCase(unittest.TestCase): def test_dbmigrate_init_no_app(self): # DBMigrate always required app self.assertRaises(TypeError, DBMigrate) def test_dbmigrate_init_app_no_config(self): app = Flask(__name__) self.assertRaises(ImproperlyConfigured, DBMigrate, app=app) def test_dbmigrate_init_app_config(self): app = Flask(__name__) app.config.from_object(TestConfig) DBMigrate(app) class DBMigrateSubManagerTestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.output = StringIO() sys.stdout = self.output def tearDown(self): self.output.close() def test_add_dbmigrate_submanager(self): dbmigrate_manager = Manager() manager = Manager(self.app) manager.add_command('dbmigrate', dbmigrate_manager) assert isinstance(manager._commands['dbmigrate'], Manager) self.assertEquals(dbmigrate_manager.parent, manager) self.assertEquals(dbmigrate_manager.get_options(), manager.get_options()) def test_run_dbmigrate_test(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'test'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) assert 'test ok' in self.output.getvalue() class DBMigrateCommandsTestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.app.config.from_object(TestConfig) self.app.config['SQLALCHEMY_MIGRATE_REPO'] += self.id() self.app.db = SQLAlchemy(self.app) self.Test = make_test_model(self.app.db) self.dbmigrate = DBMigrate(self.app) self.output = StringIO() sys.stdout = self.output def tearDown(self): self.output.close() if os.path.exists(self.app.config['SQLALCHEMY_MIGRATE_REPO']): rmtree(self.app.config['SQLALCHEMY_MIGRATE_REPO']) if os.path.exists(rel('test.sqlite3')): os.remove(rel('test.sqlite3')) def test_init(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'init'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) self.assertTrue(os.path.exists( self.app.config['SQLALCHEMY_MIGRATE_REPO'])) migration = os.path.join(self.app.config['SQLALCHEMY_MIGRATE_REPO'], 'versions/001_initial.py') self.assertTrue(os.path.exists(migration)) # drop self.dbmigrate._drop() def test_schemamigrate_no_repository(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'schemamigration'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) output = sys.stdout.getvalue().strip() self.assertEquals(output, 'You have no database under version ' 'control. Try to "init" it first') @with_database def test_schemamigrate_no_changes(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'schemamigration'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) output = sys.stdout.getvalue().strip() self.assertEquals(output, 'No Changes!') @with_database_changes def test_schemamigrate_with_changes(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'schemamigration'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) migration = os.path.join(self.app.config['SQLALCHEMY_MIGRATE_REPO'], 'versions/002_auto_generated.py') self.assertTrue(os.path.exists(migration)) @with_database_changes def test_schemamigrate_with_changes_named(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'schemamigration', '-n', 'migration_name'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) migration = os.path.join(self.app.config['SQLALCHEMY_MIGRATE_REPO'], 'versions/002_migration_name.py') self.assertTrue(os.path.exists(migration)) @with_database_changes def test_schemamigrate_with_changes_stdout(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'schemamigration', '--stdout'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) output = sys.stdout.getvalue().strip() pattern = re.compile('^# __VERSION__: (?P<version>\d+)\n') self.assertTrue(re.search(pattern, output)) def test_migrate_show_no_migrations(self): self.dbmigrate.init() migration = os.path.join(self.app.config['SQLALCHEMY_MIGRATE_REPO'], 'versions/001_initial.py') if os.path.exists(migration): os.remove(migration) manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'migrate', '--show'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) assert 'No migrations!' in sys.stdout.getvalue().strip() self.dbmigrate._drop() @with_database_changes def test_migrate_show_with_migrations(self): self.dbmigrate.db = self.app.db self.dbmigrate.schemamigrate(migration_name='added_column2') manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'migrate', '--show'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) out = sys.stdout.getvalue().strip() assert '( ) 002_added_column2 (ver. 2)' in out @with_database_changes def test_migrate_upgrade(self): self.dbmigrate.db = self.app.db self.dbmigrate.schemamigrate(migration_name='added_column2') manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'migrate'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) assert self.dbmigrate._get_db_version() == \ self.dbmigrate._get_repo_version() i = Inspector(self.dbmigrate.db.engine) # check if table "test" exist assert 'test' in i.get_table_names() # check if column "column2" exists in table "test" assert 'column2' in [c['name'] for c in i.get_columns('test')] @with_database def test_migrate_downgrade_to_0(self): manager = Manager(self.app) manager.add_command('dbmigrate', dbmanager) sys.argv = ['manage.py', 'dbmigrate', 'migrate', '-v', '0'] try: manager.run() except SystemExit, e: self.assertEquals(e.code, 0) i = Inspector(self.dbmigrate.db.engine) # check if table "test" does not exist assert 'test' not in i.get_table_names() class DBMigrateRelationshipsTestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.app.config.from_object(TestConfig) # Use unique repository for each test self.app.config['SQLALCHEMY_MIGRATE_REPO'] += self.id() self.app.db = SQLAlchemy(self.app) self.output = StringIO() sys.stdout = self.output def tearDown(self): self.dbmigrate._drop() self.output.close() if os.path.exists(self.app.config['SQLALCHEMY_MIGRATE_REPO']): rmtree(self.app.config['SQLALCHEMY_MIGRATE_REPO']) if os.path.exists(rel('test.sqlite3')): os.remove(rel('test.sqlite3')) def test_one_to_many_relationship(self): # initial "parent" table class Parent(self.app.db.Model): __tablename__ = 'parent' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate = DBMigrate(self.app) self.dbmigrate.init() self.dbmigrate._upgrade() # check that table "parent" has been properly created assert 'parent' in Inspector(self.dbmigrate.db.engine ).get_table_names() self.app.db = SQLAlchemy(self.app) # add o2m rel to "child" table class Parent(self.app.db.Model): __tablename__ = 'parent' id = self.app.db.Column(self.app.db.Integer, primary_key=True) children = self.app.db.relationship("Child") class Child(self.app.db.Model): __tablename__ = 'child' id = self.app.db.Column(self.app.db.Integer, primary_key=True) parent_id = self.app.db.Column(self.app.db.Integer, self.app.db.ForeignKey('parent.id')) self.dbmigrate.db = self.app.db self.dbmigrate.schemamigrate(migration_name='added_child_table') self.dbmigrate._upgrade() # check that table "child" has been properly created assert 'child' in Inspector(self.dbmigrate.db.engine ).get_table_names() # downgrade to 1 self.dbmigrate.migrate(upgrade=False, version=1) # check that table "child" has been properly deleted assert 'child' not in Inspector(self.dbmigrate.db.engine ).get_table_names() def test_many_to_one_relationship(self): # initial "parent" table class Parent(self.app.db.Model): __tablename__ = 'parent' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate = DBMigrate(self.app) self.dbmigrate.init() self.dbmigrate._upgrade() # check that table "parent" has been properly created assert 'parent' in Inspector(self.dbmigrate.db.engine ).get_table_names() self.app.db = SQLAlchemy(self.app) # add m2o rel to "child" table class Parent(self.app.db.Model): __tablename__ = 'parent' id = self.app.db.Column(self.app.db.Integer, primary_key=True) child_id = self.app.db.Column(self.app.db.Integer, self.app.db.ForeignKey('child.id')) child = self.app.db.relationship("Child") class Child(self.app.db.Model): __tablename__ = 'child' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate.db = self.app.db self.dbmigrate.schemamigrate(migration_name='added_child_table') self.dbmigrate._upgrade() # check that table "child" has been properly created assert 'child' in Inspector(self.dbmigrate.db.engine ).get_table_names() # downgrade to 1 self.dbmigrate.migrate(upgrade=False, version=1) # check that table "child" has been properly deleted assert 'child' not in Inspector(self.dbmigrate.db.engine ).get_table_names() def test_one_to_one_relationship(self): # initial "parent" table class Parent(self.app.db.Model): __tablename__ = 'parent' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate = DBMigrate(self.app) self.dbmigrate.init() self.dbmigrate._upgrade() # check that table "parent" has been properly created assert 'parent' in Inspector(self.dbmigrate.db.engine ).get_table_names() self.app.db = SQLAlchemy(self.app) # add o2o rel to "child" table class Parent(self.app.db.Model): __tablename__ = 'parent' id = self.app.db.Column(self.app.db.Integer, primary_key=True) child = self.app.db.relationship("Child", uselist=False, backref="parent") class Child(self.app.db.Model): __tablename__ = 'child' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate.db = self.app.db self.dbmigrate.schemamigrate(migration_name='added_child_table') self.dbmigrate._upgrade() # check that table "child" has been properly created assert 'child' in Inspector(self.dbmigrate.db.engine ).get_table_names() # downgrade to 1 self.dbmigrate.migrate(upgrade=False, version=1) # check that table "child" has been properly deleted assert 'child' not in Inspector(self.dbmigrate.db.engine ).get_table_names() def test_many_to_many_relationship(self): # initial "left" table class Parent(self.app.db.Model): __tablename__ = 'left' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate = DBMigrate(self.app) self.dbmigrate.init() self.dbmigrate._upgrade() # check that table "left" has been properly created assert 'left' in Inspector(self.dbmigrate.db.engine ).get_table_names() self.app.db = SQLAlchemy(self.app) # add m2m rel to "child" table through "association" association_table = self.app.db.Table('association', self.app.db.Model.metadata, self.app.db.Column('left_id', self.app.db.Integer, self.app.db.ForeignKey('left.id')), self.app.db.Column('right_id', self.app.db.Integer, self.app.db.ForeignKey('right.id')) ) class Parent(self.app.db.Model): __tablename__ = 'left' id = self.app.db.Column(self.app.db.Integer, primary_key=True) children = self.app.db.relationship("Child", secondary=association_table) class Child(self.app.db.Model): __tablename__ = 'right' id = self.app.db.Column(self.app.db.Integer, primary_key=True) self.dbmigrate.db = self.app.db self.dbmigrate.schemamigrate(migration_name='added_child_table') self.dbmigrate._upgrade() # check that table "association" has been properly created assert 'association' in Inspector(self.dbmigrate.db.engine ).get_table_names() # check that table "right" has been properly created assert 'right' in Inspector(self.dbmigrate.db.engine ).get_table_names() def suite(): suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DBMigrateInitTestCase)) suite.addTest(unittest.makeSuite(DBMigrateSubManagerTestCase)) suite.addTest(unittest.makeSuite(DBMigrateCommandsTestCase)) suite.addTest(unittest.makeSuite(DBMigrateRelationshipsTestCase)) return suite if __name__ == '__main__': unittest.main(defaultTest='suite')

UTF-8

Python

py

tests.py

borgbackup/borg

cfe1246f12a30fb2bc00c6d3604c3882ae592017

fb05fb9f9f7fe7eb91072ad62c10200cae10acc6

/src/borg/testsuite/archiver/patterns.py

c4863bb94fe90ffe1df72f4e319f8a8970c145b6

permissive

https://github.com/borgbackup/borg

c83f2a34e8bcc19859e9696a9425cbf4e23a743c

4ded3620c5e9cd930d2e07e912af6c894abe6d5d

refs/heads/master

NOASSERTION

Python

from ...archiver._common import build_filter from ...constants import * # NOQA from ...patterns import IECommand, PatternMatcher, parse_pattern from ...item import Item def test_basic(): matcher = PatternMatcher() matcher.add([parse_pattern("included")], IECommand.Include) filter = build_filter(matcher, 0) assert filter(Item(path="included")) assert filter(Item(path="included/file")) assert not filter(Item(path="something else")) def test_empty(): matcher = PatternMatcher(fallback=True) filter = build_filter(matcher, 0) assert filter(Item(path="anything")) def test_strip_components(): matcher = PatternMatcher(fallback=True) filter = build_filter(matcher, strip_components=1) assert not filter(Item(path="shallow")) assert filter(Item(path="deep enough/file")) assert filter(Item(path="something/dir/file"))

UTF-8

Python

py

patterns.py

slimwangyue/pytorch-cifar

e959934789f2535d170a25f86b20259b30caee37

f5c1f8c9238cb5f1b719e9a27f0240c1b77bdb7d

/MobileNet_train/train.py

aabb612a9123bb9404c37bf5932387d3414b747d

permissive

https://github.com/slimwangyue/pytorch-cifar

61653653076010d47bbec7c4209a3b1a9738a949

d6ddd10cee5b78d6994b1683f605e541513b85d1

refs/heads/master

import argparse import os import sys import time import torch import torch.nn.functional as F import torchvision import models import utils import tabulate from tensorboardX import SummaryWriter import torchvision.transforms as transforms def str2bool(s): return s.lower() in ['yes', '1', 'true', 'y'] parser = argparse.ArgumentParser(description='SGD/SWA training') parser.add_argument('--dir', type=str, default=None, required=True, help='training directory (default: None)') parser.add_argument('--dataset', type=str, default='CIFAR10', help='dataset name (default: CIFAR10)') parser.add_argument('--data_path', type=str, default=None, required=True, metavar='PATH', help='path to datasets location (default: None)') parser.add_argument('--batch_size', type=int, default=256, metavar='N', help='input batch size (default: 128)') parser.add_argument('--num_workers', type=int, default=16, metavar='N', help='number of workers (default: 4)') parser.add_argument('--model', type=str, default=None, required=True, metavar='MODEL', help='model name (default: None)') parser.add_argument('--resume', type=str, default=None, metavar='CKPT', help='checkpoint to resume training from (default: None)') parser.add_argument('--epochs', type=int, default=200, metavar='N', help='number of epochs to train (default: 200)') parser.add_argument('--save_freq', type=int, default=25, metavar='N', help='save frequency (default: 25)') parser.add_argument('--eval_freq', type=int, default=5, metavar='N', help='evaluation frequency (default: 5)') parser.add_argument('--lr_init', type=float, default=0.03, metavar='LR', help='initial learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='SGD momentum (default: 0.9)') parser.add_argument('--wd', type=float, default=1e-4, help='weight decay (default: 1e-4)') parser.add_argument('--swa', action='store_true', help='swa usage flag (default: off)') parser.add_argument('--swa_start', type=float, default=161, metavar='N', help='SWA start epoch number (default: 161)') parser.add_argument('--swa_lr', type=float, default=0.01, metavar='LR', help='SWA LR (default: 0.05)') parser.add_argument('--swa_c_epochs', type=int, default=1, metavar='N', help='SWA model collection frequency/cycle length in epochs (default: 1)') parser.add_argument('--energy', default=1, type=int, help='using energy as regularization term') parser.add_argument('--beta', default=6e-5, type=float, help='coefficient') parser.add_argument('--minimum', default=80, type=float, help='minimum') # Quantization of input, weight, bias and grad parser.add_argument('--num_bits', default=8, type=int, help='precision of input/activation') parser.add_argument('--num_bits_weight', default=8, type=int, help='precision of weight') parser.add_argument('--num_bits_grad', default=16, type=int, help='precision of (layer) gradients') parser.add_argument('--biprecision', default=False, type=str2bool, help='use biprecision or not') # Predictive (sign) SGD arguments parser.add_argument('--predictive_forward', default=False, type=str2bool, help='use predictive net in forward pass') parser.add_argument('--predictive_backward', default=True, type=str2bool, help='use predictive net in backward pass') parser.add_argument('--msb_bits', default=4, type=int, help='precision of msb part of input') parser.add_argument('--msb_bits_weight', default=2, type=int, help='precision of msb part of weight') parser.add_argument('--msb_bits_grad', default=8, type=int, help='precision of msb part of (layer) gradient') parser.add_argument('--threshold', default=5e-5, type=float, help='threshold to use full precision gradient calculation') parser.add_argument('--sparsify', default=False, type=str2bool, help='sparsify the gradients using predictive net method') parser.add_argument('--sign', default=True, type=str2bool, help='take sign before applying gradient') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') args = parser.parse_args() skip_count = 0 descriptions = [ args.model, 'g:%d' % args.num_bits_grad, 'mg:%d' % args.msb_bits_grad, 'th:%f' % args.threshold, 'minimum:%f' % args.minimum, 'lr:%f' % args.lr_init, 'wd:%f' % args.wd, # 'sr:%f' % args.step_ratio, ] args.exp_desc = '-'.join(filter(None, descriptions)) print('Preparing directory %s' % args.dir) os.makedirs(args.dir, exist_ok=True) with open(os.path.join(args.dir, 'command.sh'), 'w') as f: f.write(' '.join(sys.argv)) f.write('\n') torch.backends.cudnn.benchmark = True torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) print('Using model %s' % args.model) model_cfg = getattr(models, args.model) print('Loading dataset %s from %s' % (args.dataset, args.data_path)) ds = getattr(torchvision.datasets, args.dataset) path = os.path.join(args.data_path, args.dataset.lower()) transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) train_set = ds(path, train=True, download=True, transform=transform_train) test_set = ds(path, train=False, download=True, transform=transform_test) loaders = { 'train': torch.utils.data.DataLoader( train_set, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, pin_memory=True ), 'test': torch.utils.data.DataLoader( test_set, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, pin_memory=True ) } num_classes = 100 + 1 writer_path = os.path.join('runs', args.exp_desc + '-' + time.strftime('%Y-%m-%d-%H:%M:%S', time.localtime())) writer = SummaryWriter(writer_path) signsgd_config = { 'num_bits': args.num_bits, 'num_bits_weight': args.num_bits_weight, 'num_bits_grad': args.num_bits_grad, 'biprecision': args.biprecision, 'predictive_forward': args.predictive_forward, 'predictive_backward': args.predictive_backward, 'msb_bits': args.msb_bits, 'msb_bits_weight': args.msb_bits_weight, 'msb_bits_grad': args.msb_bits_grad, 'threshold': args.threshold, 'sparsify': args.sparsify, 'sign': args.sign, 'writer': writer, } print('Preparing model') # model = model_cfg.base(*model_cfg.args, num_classes=num_classes, **model_cfg.kwargs) # model = models.__dict__[args.model](None, **signsgd_config) model = models.MobileNetV2(10, **signsgd_config) # model.install_gate() model = torch.nn.DataParallel(model).cuda() if args.swa: print('SWA training') # swa_model = models.__dict__[args.model](None, **signsgd_config) swa_model = models.MobileNetV2(10, **signsgd_config) # swa_model.install_gate() swa_model = torch.nn.DataParallel(swa_model).cuda() swa_n = 0 else: print('SGD training') def schedule(epoch): t = (epoch) / (args.swa_start if args.swa else args.epochs) lr_ratio = args.swa_lr / args.lr_init if args.swa else 0.01 if t <= 0.5: factor = 1.0 elif t <= 0.9: factor = 1.0 - (1.0 - lr_ratio) * (t - 0.5) / 0.4 else: factor = lr_ratio return args.lr_init * factor criterion = F.cross_entropy optimizer = torch.optim.SGD( model.parameters(), lr=args.lr_init, momentum=args.momentum, weight_decay=args.wd ) start_epoch = 0 if args.resume is not None: print('Resume training from %s' % args.resume) checkpoint = torch.load(args.resume) start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) if args.swa: swa_state_dict = checkpoint['swa_state_dict'] if swa_state_dict is not None: swa_model.load_state_dict(swa_state_dict) swa_n_ckpt = checkpoint['swa_n'] if swa_n_ckpt is not None: swa_n = swa_n_ckpt columns = ['ep', 'lr', 'tr_loss', 'tr_acc', 'te_loss', 'te_acc', 'time'] if args.swa: columns = columns[:-1] + ['swa_te_loss', 'swa_te_acc'] + columns[-1:] swa_res = {'loss': None, 'accuracy': None} utils.save_checkpoint( args.dir, start_epoch, state_dict=model.state_dict(), swa_state_dict=swa_model.state_dict() if args.swa else None, swa_n=swa_n if args.swa else None, optimizer=optimizer.state_dict() ) # global total_i total_i = 0 # global training_cost training_cost = 0 for epoch in range(start_epoch, args.epochs): time_ep = time.time() lr = schedule(epoch) utils.adjust_learning_rate(optimizer, lr) train_res, total_i, training_cost = utils.train_epoch(loaders['train'], model, criterion, optimizer, args, writer, total_i, skip_count, training_cost) if epoch == 0 or epoch % args.eval_freq == args.eval_freq - 1 or epoch == args.epochs - 1: test_res = utils.eval(loaders['test'], model, criterion, writer, total_i, skip_count) else: test_res = {'loss': None, 'accuracy': None} if args.swa and (epoch + 1) >= args.swa_start and (epoch + 1 - args.swa_start) % args.swa_c_epochs == 0: utils.moving_average(swa_model, model, 1.0 / (swa_n + 1)) swa_n += 1 if epoch == 0 or epoch % args.eval_freq == args.eval_freq - 1 or epoch == args.epochs - 1: utils.bn_update(loaders['train'], swa_model) swa_res = utils.eval(loaders['test'], swa_model, criterion, writer, total_i, skip_count) else: swa_res = {'loss': None, 'accuracy': None} if (epoch + 1) % args.save_freq == 0: utils.save_checkpoint( args.dir, epoch + 1, state_dict=model.state_dict(), swa_state_dict=swa_model.state_dict() if args.swa else None, swa_n=swa_n if args.swa else None, optimizer=optimizer.state_dict() ) time_ep = time.time() - time_ep values = [epoch + 1, lr, train_res['loss'], train_res['accuracy'], test_res['loss'], test_res['accuracy'], time_ep] if args.swa: values = values[:-1] + [swa_res['loss'], swa_res['accuracy']] + values[-1:] table = tabulate.tabulate([values], columns, tablefmt='simple', floatfmt='8.4f') if epoch % 40 == 0: table = table.split('\n') table = '\n'.join([table[1]] + table) else: table = table.split('\n')[2] print(table) if args.epochs % args.save_freq != 0: utils.save_checkpoint( args.dir, args.epochs, state_dict=model.state_dict(), swa_state_dict=swa_model.state_dict() if args.swa else None, swa_n=swa_n if args.swa else None, optimizer=optimizer.state_dict() )

UTF-8

Python

py

train.py

skinkie/Scripts

a95298a851ab24b8d4b2eb31a0aea301730f7ef4

c5744c2fda48ae6a79c155c641fe98021a0cb7f3

/Exercise/mymod.py

cb8aa3b66a6f266638ec42a1306081d2f40ae155

no_license

https://github.com/skinkie/Scripts

e0fd3d3f767612ade111f28bc7af3e1b25fc2947

80a1ba71ddf9a0c5ff33866832cb5c42aca0c0b1

refs/heads/master

""" Read a file and counts its lines and characters. """ def countLines(name): name.seek(0) lines = name.readlines() tot = 0 for i in lines: tot += 1 return tot """ def countLines(name): name.seek(0) lines = name.readlines() return len(lines) """ def countChars(name): name.seek(0) chars = name.read() tot = 0 for i in chars: tot += 1 return tot """ def countChars(name): name.seek(0) chars = name.read() return len(chars) """ def test(filename): name = open(filename) print('This file has %s lines and %s chars!' %(countLines(name), countChars(name))) """ def test(filename): import time start = time.time() count(filename) passed = time.time() - start print('Time uses: ', passed) """ if __name__ == '__main__': import sys test(sys.argv[1])

UTF-8

Python

py

mymod.py

pywjh/MeiDuoByDjango1

52de0437c70fe140ee1f7aedf81f34e3000e82e5

87b4454b12c5cf7afaf596065b4c2c232381249a

/celery_tasks/sms/tasks.py

69e8e1f5e217c29cb373628c54bfe51de0887a19

no_license

https://github.com/pywjh/MeiDuoByDjango1

7153ea72b9f5c9c2a6c95859a5fe6a178c0aaa69

9f38360a940cc7fe7157ad758ecad4c1d6e219b7

refs/heads/main

from celery_tasks.sms.yuntongxun.sms import CCP from celery_tasks.sms import constants # from verifications import constants from celery_tasks.main import celery_app # name=自定义任务名字 @celery_app.task(name='send_sms_code') def send_sms_code(mobile, sms_code): # CCP().send_template_sms('接收短信手机号', ['短信验证码', '提示用户短信验证码多久过期单位分钟'], '模板id') CCP().send_template_sms(mobile, [sms_code, constants.SMS_CODE_EXPIRE // 60], 1)

UTF-8

Python

py

tasks.py

Sergey582/CT-APP-Rest-Api

83527efb6b32ab5e347e32e1cec8895417af21a7

762508060dade05f86f9783ac7395a5eb31911a6

/android app/postman/data/models.py

558476c6998b229617e987b0b8a8b381699f1b0b

no_license

https://github.com/Sergey582/CT-APP-Rest-Api

28826fe8d55f3e5df2e27d30076985871ea8a749

fbc786799ae1bcff2c3315d755c788a3bb4dc32f

refs/heads/master

from django.db import models class Test(models.Model): year = models.IntegerField(default=0) number = models.IntegerField() subject = models.CharField(max_length=250) class Task(models.Model): part = models.CharField(max_length=250) number = models.IntegerField() task_text = models.TextField() test = models.ForeignKey('Test', related_name='tasks', on_delete=models.CASCADE) class Answer(models.Model): answer_text = models.TextField() is_true = models.BooleanField(default=False) task = models.ForeignKey('Task', related_name='answers', on_delete=models.CASCADE)

UTF-8

Python

py

models.py

lucasjurado/Hackathon-ImagiMaker

db3dab254f9b9c1911927dc437e0896c83707a8b

eebe81968e7957c5b52e54b0800d0a24a08fe420

/lucas_jurado_iniciante_desafio2.py

72f0b9a02dfad5a39b6cf1478e4cb8a6b6f7e21d

permissive

https://github.com/lucasjurado/Hackathon-ImagiMaker

feefe7ef7e622a73b962f1bdcdcce941c095164b

69974450e77b5b03bfcfdee9dcbaf0eb62708032

refs/heads/master

import random print('<<<<<<<<< Jokenpô >>>>>>>>>') #variavel recebe o nome do jogador nome = str(input('Qual é o seu nome? ')) #contador do número de jogos c = 0 #contador das vitórias do pc pcWin = 0 #contador das vitórias do jogador playerWin = 0 #contador de empates draw = 0 while True: #variável recebe a opção do jogador de acordo com a sua referencia(0,1,2) num = int(input('''Suas opções: [0] Pedra [1] Papel [2] Tesoura Qual é a sua jogada? ''')) #se o valor da variável for diferente das apresentadas, o programa pede novamente para digitá-la if num != 0 and num != 1 and num != 2: print('Opção inválida! Tente novamente') print('-=' * 20) else: print('-='*20) #o computador escolhe uma das opções randomizadas dentro da lista lista = ('Pedra','Papel','Tesoura') pc = random.choice(lista) p1 = lista[num] print(f'{nome} [{p1}] X [{pc}] Computador') #sequencia lógica que define o vencedor e o atribui 1 ponto no caso de vitória if pc == p1: print('> Empate!') draw += 1 elif pc == 'Pedra' and p1 == 'Papel' or pc == 'Papel' and p1 == 'Tesoura' or pc == 'Tesoura' and p1 == 'Pedra': print(f'> {nome}, você venceu!') playerWin += 1 else: print(f'> {nome}, você perdeu!') pcWin += 1 print('-=' * 20) #contador de jogos recebe mais 1 e caso o seu total seja multiplo de 5, é perguntado se deseja continuar o jogo c+=1 if c%5==0: while True: again = str(input('Você quer continuar [S/N]? ')).upper().strip()[0] print('-=' * 20) if again in 'SN': if again in 'N': print(f'<Depois de {c} jogos> Placar final: {nome} {playerWin} x {pcWin} Computador. E {draw} empates.') exit() elif again in 'S': break else: print('Opção inválida! Tente novamente.')

UTF-8

Python

py

lucas_jurado_iniciante_desafio2.py

rgarcia5/project_euler

9ed20af2678e07383d4fe7c4981196ef8e81248c

2823f546b288b711b72f3bdef404ef6208cc5021

/python/problem25.py

7028cd794050d57083016f9105045be47e0a0bbc

no_license

https://github.com/rgarcia5/project_euler

d431ff1ac87cb59d99281947b1434292fa4f3a60

51412a020e90071dbfb1ac26a637e7292560483c

refs/heads/master

def fibonacci_sequence(): count = 1 first_num = 1 second_num = 1 while (len(str(first_num)) != 1000): result = first_num + second_num first_num = second_num second_num = result count += 1 return count print fibonacci_sequence()

UTF-8

Python

py

problem25.py

tomography/xdesign

0f7928a0665e8a8c4cbc1f550a27aa2e9b3a6e39

1efa22ec38c51644f608711064324c3e7c8c2f08

/src/xdesign/codes.py

060c6d7bcce80236f2d5f1824e804591d9ea12ff

permissive

https://github.com/tomography/xdesign

e282f2b3f6ee9893801c161bb61ec73130f3a3ff

778914cf9df60d1b96b996ef463825ee455ece4f

refs/heads/master

#!/usr/bin/env python # -*- coding: utf-8 -*- # ######################################################################### # Copyright (c) 2019, UChicago Argonne, LLC. All rights reserved. # # # # Copyright 2019. UChicago Argonne, LLC. This software was produced # # under U.S. Government contract DE-AC02-06CH11357 for Argonne National # # Laboratory (ANL), which is operated by UChicago Argonne, LLC for the # # U.S. Department of Energy. The U.S. Government has rights to use, # # reproduce, and distribute this software. NEITHER THE GOVERNMENT NOR # # UChicago Argonne, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR # # ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is # # modified to produce derivative works, such modified software should # # be clearly marked, so as not to confuse it with the version available # # from ANL. # # # # Additionally, redistribution and use in source and binary forms, with # # or without modification, are permitted provided that the following # # conditions are met: # # # # * Redistributions of source code must retain the above copyright # # notice, this list of conditions and the following disclaimer. # # # # * Redistributions in binary form must reproduce the above copyright # # notice, this list of conditions and the following disclaimer in # # the documentation and/or other materials provided with the # # distribution. # # # # * Neither the name of UChicago Argonne, LLC, Argonne National # # Laboratory, ANL, the U.S. Government, nor the names of its # # contributors may be used to endorse or promote products derived # # from this software without specific prior written permission. # # # # THIS SOFTWARE IS PROVIDED BY UChicago Argonne, LLC AND CONTRIBUTORS # # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL UChicago # # Argonne, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, # # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT # # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN # # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # # POSSIBILITY OF SUCH DAMAGE. # # ######################################################################### """Generate codes for space- and time-coded apertures. .. moduleauthor:: Daniel Ching """ import logging import numpy as np logger = logging.getLogger(__name__) __author__ = "Daniel Ching" __copyright__ = "Copyright (c) 2019, UChicago Argonne, LLC." __docformat__ = 'restructuredtext en' __all__ = ['mura_1d', 'mura_2d', 'raskar'] def is_prime(n): """Return True if n is prime.""" if n == 2 or n == 3: return True if n < 2 or n % 2 == 0: return False if n < 9: return True if n % 3 == 0: return False r = int(n**0.5) f = 5 while f <= r: if n % f == 0: return False if n % (f+2) == 0: return False f += 6 return True def quadratic_residues_modulo(n): """Return all quadratic residues modulo n in the range 0, ..., n-1. q is a quadratic residue modulo n if it is congruent to a perfect square modulo n. """ x = np.arange(n) q = x**2 % n return q def mura_1d(L): """Return the longest MURA whose length is less than or equal to L. From Wikipedia: A Modified uniformly redundant array (MURA) can be generated in any length L that is prime and of the form:: L = 4m + 1, m = 1, 2, 3, ..., the first six such values being ``L = 5, 13, 17, 29, 37``. The binary sequence of a linear MURA is given by ``A[0:L]`` where:: A[i] = { 0 if i = 0, 1 if i is a quadratic residue modulo L, i != 0, 0 otherwise, } """ if L < 5: raise ValueError("A MURA cannot have length less than 5.") # overestimate m to guess a MURA longer than L m = (L + 1) // 4 L1 = (4 * m) + 1 # find an allowed MURA length, L1, <= L while not (L1 <= L and is_prime(L1)): m = m - 1 L1 = (4 * m) + 1 # Compute the MURA A = np.zeros(L1, dtype=np.bool) A[quadratic_residues_modulo(L1)] = 1 A[0] = 0 print("MURA is length {}".format(L1)) assert L1 <= L, "len(MURA) should be <= {}, but it's {}.".format(L, L1) return A def mura_2d(M, N=None): """Return the largest 2D MURA whose lengths are less than M and N. From Wikipedia: A rectangular MURA, ``A[0:M, 0:N]``, is defined as follows:: A[i, j] = { 0 if i = 0, 1 if j = 0, i != 0, 1 if C[i] * C[j] = 1, 0 othewise, } C[i] = { 1 if i is a quadratic residue modulo p, -1 otherwise, } where p is the length of the matching side M, N. """ # Use 1D Muras to start Ci = mura_1d(M).astype(np.int8) M1 = len(Ci) if N is None: N1 = M1 Cj = np.copy(Ci) else: Cj = mura_1d(N).astype(np.int8) N1 = len(Cj) # Modify 1D Muras to match 2D mura coefficients; ignore i, j = 0 those are # set later. Ci[Ci != 1] = -1 Cj[Cj != 1] = -1 # Arrays must be 2D for matrix multiplication Ci = Ci[..., np.newaxis] Cj = Cj[np.newaxis, ...] A = (Ci @ Cj) == 1 assert A.shape[0] == M1 and A.shape[1] == N1, \ "A is not the correct shape! {} != ({}, {})".format(A.shape, M1, N1) A[0, :] = 0 A[:, 0] = 1 return A def raskar(npool): """Return the coded mask from Raskar et al.""" return np.array([1, 0, 1, 0, 0, 0, 1, 0, 1, 1, # 10 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, # 20 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, # 30 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, # 40 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, # 50 1, 1], dtype='bool') # must be boolean

UTF-8

Python

py

codes.py