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,700 | clientamppt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientamppt.cpython-38.pyc | U
#ôıc‰ ã @ st d dl Z d dlmZ d dlmZ d dlZd dlZd dlZd dlZd dl m
Z
d dl m Z G dd„ deƒZ
dd„ ZdS ) é N)ÚClient)Úlabel_binarize)Úmetricsc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientAMPPTc s¦ t ƒ j||||f|� |j| _|j| _t | j¡| _t ¡ | _
t j
| jj ¡ | jdœg¡| _|j| _t j j
| jj ¡ |j|jd�| _t j jj| j| j|jd�| _d S )N)ÚparamsÚlr)r Úmomentum)Ú step_sizeÚgamma)ÚsuperÚ__init__ÚalphaKÚlamdaÚcopyÚdeepcopyÚmodelÚclient_uÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚ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\clientamppt.pyr s
ÿÿÿzclientAMPPT.__init__c C s | ¡ }t ¡ }t | jj¡}| j | j¡ | j | j¡ | j ¡ | jj
¡ D ]
}d|_ qP| jj ¡ D ]
}d|_ qht
| jƒD ]´}t|ƒD ]¦\}\}}t|ƒtg ƒkr¼|d | j¡|d< n | | j¡}| | j¡}| jrôt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ | j ¡ qŠq~| j } | j�rTtj d| d ¡} | jj
¡ D ] }d|_ �q`| jj ¡ D ] }d|_ �qzt
| ƒD ]æ}|D ]Ú\}}t|ƒtg ƒk�rÈ|d | j¡|d< n | | j¡}| | j¡}| j�rt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
t | jƒ} t | jƒ}
| |
}|
| j!| j" d t# $||¡ 7 }
|
¡ | 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š™™™™™¹?é é Ú
num_roundsÚ
total_cost)+Úload_train_dataÚtimer r r r ÚtoÚdevicer Útrainr r Ú
requires_gradÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepr$ Ú local_stepsÚrandintr Úweight_flattenr r
r ÚdotÚcpuÚzipÚwhereÚ
zeros_likeÚsumÚtrain_time_cost)r% Ú trainloaderÚ
start_timeÚ
old_promptÚparamrD ÚiÚxÚyÚoutputr Úmax_local_stepsr Úparams_ÚsubÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror- r- r. r7 sx
zclientAMPPT.trainc C s< t |j ¡ | jj ¡ ƒD ] \}}|j||j ¡ |_qd S )N)rJ r r r ÚdataÚclone)r% r Ú coef_selfr\ r] r- r- r. Úset_parametersi s zclientAMPPT.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 r5 r6 Úevalr Úno_gradr; r rM ÚargmaxÚitemÚshapeÚappendÚdetachrI Únumpyr r> ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r% ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerT rU rV Úoutput2Úaucr- r- r. Ú test_metricsm s4
2
zclientAMPPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r7 rb r} Ú
__classcell__r- r- r+ r. r s Ir c C s0 g }| ¡ D ]}| | d¡¡ q t |¡}|S )Néÿÿÿÿ)r rn Úviewr Úcat)r r Úur- r- r. rG ” s
rG )r Útorch.nnr Úflcore.clients.clientbaser rp r> r4 r Úsklearn.preprocessingr Úsklearnr r rG r- r- r- r. Ú<module> s
| 4,168 | Python | .py | 48 | 85.666667 | 553 | 0.415291 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,701 | clientrep.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientrep.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 )Ú clientRepc 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ÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚ predictorÚ
poptimizerÚ plocal_steps)Ú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/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_parametersL s zclientRep.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r' rF Ú
__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,347 | Python | .py | 32 | 72.1875 | 294 | 0.431779 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,702 | clientamp.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientamp.cpython-39.pyc | a
f¾`cÍ ã @ 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||||fi |¤� |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__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientamp.pyr
s
zclientAMP.__init__c C sR | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD ]Ş}|D ]Ô\}}t
|ƒt
g ƒkrv|d | j ¡|d< n | | j ¡}| | j ¡}| jr®t
dt tj ¡ ¡ ¡ | j ¡ | |¡}| ||¡}t| jƒ} t| jƒ}
| |
} || j| j d t | | ¡ 7 }| ¡ | j ¡ qHq@~| 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ÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr Úweight_flattenr r r r ÚdotÚbackwardÚstepÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr7 ÚxÚyÚoutputr ÚparamsZparams_Úsubr r r r& s4
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& rG Ú
__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 B s
r4 ) r Útorch.nnr
Úflcore.clients.clientbaser Únumpyr) r% r r r4 r r r r Ú<module> s 9 | 2,249 | Python | .py | 24 | 92.625 | 277 | 0.44699 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,703 | clientpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientpt.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 s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚclientPTc 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Ú generatorZpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRZlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õV D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientpt.pyr s
ÿÿzclientPT.__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_timeZ
old_promptÚparamr> ÚiÚxÚyÚoutputr Úmax_local_stepsZ
new_promptZ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror% r% r& r1 sj
zclientPT.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)rB r r r ÚdataÚclone)r r rO rP r% r% r& Úset_parametersf s zclientPT.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 r/ r0 Úevalr Úno_gradr5 r rE ÚargmaxÚitemÚshapeÚappendÚdetachrA Únumpyr r8 ÚarangeÚ num_classesÚ concatenater Ú
roc_auc_score) r ÚtestloaderfullÚtest_accÚ test_acc2Útest_numÚy_probÚy_truerK rL rM Úoutput2Úaucr% r% r& Ú test_metricsj s4
2
zclientPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r1 rT ro Ú
__classcell__r% r% r# r& r
s Ir )r Útorch.nnr rb r8 r, Úflcore.clients.clientbaser r- Úsklearn.preprocessingr Úsklearnr r r% r% r% r& Ú<module> s | 3,693 | Python | .py | 46 | 78.956522 | 553 | 0.426261 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,704 | clientpFedMe.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientpFedMe.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)ÚpFedMeOptimizer)ÚClientc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientpFedMec s† t ƒ j||||fi |¤� |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__© úu/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/clients/clientpFedMe.pyr s
ÿzclientpFedMe.__init__c C s† | ¡ }t ¡ }| j ¡ | j}| jr8tj d|d ¡}t |ƒD �]}|D ]ø\}}t
|ƒt
g ƒkrx|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 | _�q
qJq@| | j| 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ÚtypeÚtoÚdeviceÚsleepÚabsÚrandr r Ú zero_gradr ÚbackwardÚstepr r ÚzipÚdatar Ú
learning_rateÚupdate_parametersÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr4 ÚxÚyÚiÚoutputr Ú new_paramZ localweightr r r r% s4
(zclientpFedMe.trainc C s@ t | ¡ | j ¡ | jƒD ]"\}}}|j ¡ |_|j ¡ |_qd S )N)r5 r r
r r6 Úclone)r r
rA Ú old_paramZ local_paramr r r Úset_parametersE s " zclientpFedMe.set_parametersc C sŞ | ¡ }| | j| j¡ | j ¡ d}d}t ¡ �” |D ]~\}}t|ƒtg ƒkrf|d | j ¡|d< n | | j ¡}| | j ¡}| |¡}|t
tj |dd�|k¡ ¡ 7 }||j
d 7 }q8W d ƒ n1 sÌ0 Y ||fS )Nr r )Údim)Úload_test_datar8 r
r ÚevalÚtorchÚno_gradr, r- r. ÚsumÚargmaxÚitemÚshape)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,889 | Python | .py | 29 | 98.344828 | 455 | 0.454387 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,705 | clientbnpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientbnpt.cpython-38.pyc | U
T¸kc÷ ã @ 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 )Ú
clientBNPTc s� t ƒ j||||f|� t ¡ | _tjj| j ¡ | j
d�| _ 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Ú
parametersÚ
learning_rateÚ optimizerÚbaseÚ plocal_stepsÚ generatorÚpt_learning_rater Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õX D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientbnpt.pyr s
ÿzclientBNPT.__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 �r@t | j |t!|ƒƒ n
| j ¡ �q��q‚| 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Ú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 ÚprivacyÚdp_stepÚlenÚcpuÚtrain_time_costÚzipr
ÚwhereÚ
zeros_likeÚsum)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& r1 sr
zclientBNPT.trainc C sB t |j ¡ | jj ¡ ƒD ]$\\}}\}}d|kr|j ¡ |_qd S )NÚbn)rF r Únamed_parametersr ÚdataÚclone)r r r
r8 ÚonÚopr% r% r& Úset_parametersd s (zclientBNPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r1 r^ Ú
__classcell__r% r% r# r& r s Fr )
r
Útorch.nnr
Únumpyr8 r, Úflcore.clients.clientbaser r- r r% r% r% r& Ú<module> s | 2,909 | Python | .py | 41 | 69.658537 | 240 | 0.427675 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,706 | clientprox.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientprox.cpython-38.pyc | U
”jfc› ã @ sX d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚPerturbedGradientDescent)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientProxc s\ t ƒ j||||f|� |j| _t t| j ¡ ƒ¡| _t
¡ | _ t | j ¡ | j
| jd�| _d S )N)ÚlrÚmu)ÚsuperÚ__init__r ÚcopyÚdeepcopyÚlistÚmodelÚ
parametersÚ
global_paramsÚnnÚCrossEntropyLossÚlossr Ú
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientprox.pyr s
ÿzclientProx.__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¡}| j
¡ | |¡}| ||¡}| ¡ | j
| j| j¡ qVqN| 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Útyper Ú zero_gradr ÚbackwardÚstepr ÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr0 ÚxÚyÚoutputr r r r r& s*
zclientProx.trainc C s@ t | ¡ | j| j ¡ ƒD ]"\}}}|j ¡ |_|j ¡ |_qd S )N)Úzipr
r r ÚdataÚclone)r r Ú new_paramZ global_paramÚparamr r r Úset_parameters5 s " zclientProx.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r& r> Ú
__classcell__r r r r r
s r ) ÚtorchÚnumpyr) r# r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 1,963 | Python | .py | 20 | 96.9 | 283 | 0.459877 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,707 | clientprox.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientprox.cpython-39.pyc | a
f¾`c› ã @ sX d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚPerturbedGradientDescent)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientProxc s` t ƒ j||||fi |¤� |j| _t t| j ¡ ƒ¡| _t
¡ | _ t | j ¡ | j
| jd�| _d S )N)ÚlrÚmu)ÚsuperÚ__init__r ÚcopyÚdeepcopyÚlistÚmodelÚ
parametersÚ
global_paramsÚnnÚCrossEntropyLossÚlossr Ú
learning_rateÚ optimizer)Ú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/clientprox.pyr s
ÿzclientProx.__init__c 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 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ÚtypeÚtoÚdeviceÚsleepÚabsÚrandr Ú zero_gradr ÚbackwardÚstepr Útrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr3 ÚxÚyÚoutputr r r r r$ s*
zclientProx.trainc C s@ t | ¡ | j| j ¡ ƒD ]"\}}}|j ¡ |_|j ¡ |_qd S )N)Úzipr
r r ÚdataÚclone)r r Ú new_paramZ global_paramÚparamr r r Úset_parameters5 s " zclientProx.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r$ r@ Ú
__classcell__r r r r r
s r ) ÚtorchÚnumpyr' r# r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 2,029 | Python | .py | 20 | 100.3 | 293 | 0.471642 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,708 | clientreppt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientreppt.cpython-38.pyc | U
�P÷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 s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú clientREPPTc sœ t ƒ j||||f|� t ¡ | _tjj| jj
¡ | j d�| _ |j
| _
tjj| jj
¡ |jdœ| jj
¡ | j dœg|jd�| _tjjj| j| j
|jd�| _d S )N)Úlr)Úparamsr )Úmomentum)Ú step_sizeÚgamma)ÚsuperÚ__init__ÚnnÚCrossEntropyLossÚlossÚtorchÚoptimÚSGDÚmodelÚbaseÚ
parametersÚ
learning_rateÚ optimizerÚ plocal_stepsÚ generatorÚpt_learning_rateÚ predictorr Ú
poptimizerÚ lr_schedulerÚStepLRÚlearning_decayÚ scheduler)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs©Ú __class__© õY D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\clients\clientreppt.pyr
s
şıÿzclientREPPT.__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 ¡ | 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Ú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
zclientREPPT.trainc C s0 t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qd S )N)rG r r r ÚdataÚclone)r! r rV rW r) r) r* Úset_parameterso s zclientREPPT.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_metricsu s4
2
zclientREPPT.test_metrics)Ú__name__Ú
__module__Ú __qualname__r r5 r[ rv Ú
__classcell__r) r) r' r* r s Pr )r Útorch.nnr
ri r< r0 Úflcore.clients.clientbaser r1 Úsklearn.preprocessingr Úsklearnr r r) r) r) r* Ú<module> s | 3,886 | Python | .py | 51 | 74.745098 | 558 | 0.422576 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,709 | clientmtl.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientmtl.cpython-37.pyc | B
ùùecª
ã @ 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__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientmtl.pyr s
zclientMTL.__init__c C sÎ | ¡ }t ¡ }| j | j¡ | j ¡ | j}| jrFtj
d|d ¡}�x>t |ƒD �]0}�x(|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 ¡ q`W qRW | 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' rH Ú
__classcell__r r )r r r
s 1r c s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r )r3 )Ú.0Úkey)Ú
state_dictr r ú
<listcomp>Q s zflatten.<locals>.<listcomp>)rO Úkeysr Úcat)r rQ ÚWr )rO r r3 N s r3 ) r Útorch.nnr Úflcore.clients.clientbaser Únumpyr* r$ r7 rF r r3 r r r r Ú<module> s D | 2,511 | Python | .py | 26 | 95.423077 | 285 | 0.423974 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,710 | clientapfl.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientapfl.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 )Ú
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__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientapfl.pyr
s
zclientAPFL.__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 ¡ | |¡}| ||¡} | ¡ | j ¡ | j ¡ | |¡}
| |
|¡} | ¡ | j ¡ | ¡ qhq\t| j ¡ | j ¡ ƒD ]$\} }
d| j |
| j| | _ �qX| 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_stepsr6 ÚiÚxÚyÚoutputr Z
output_perZloss_perÚlpÚpr r r r( sB
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_paramsZdifrF 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,404 | Python | .py | 33 | 71.69697 | 241 | 0.42285 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,711 | clientprox.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientprox.cpython-37.pyc | B
fc› ã @ sX d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
G dd„ de
ƒZ dS )é N)ÚPerturbedGradientDescent)ÚClientc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )Ú
clientProxc s\ t ƒ j||||f|� |j| _t t| j ¡ ƒ¡| _t
¡ | _ t | j ¡ | j
| jd�| _d S )N)ÚlrÚmu)ÚsuperÚ__init__r ÚcopyÚdeepcopyÚlistÚmodelÚ
parametersÚ
global_paramsÚnnÚCrossEntropyLossÚlossr Ú
learning_rateÚ optimizer)ÚselfÚargsÚidÚ
train_samplesÚ test_samplesÚkwargs)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientprox.pyr s
zclientProx.__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¡}| j
¡ | |¡}| ||¡}| ¡ | j
| j| j¡ qZW qPW | 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Útyper Ú zero_gradr ÚbackwardÚstepr ÚcpuÚtrain_time_cost) r Ú trainloaderÚ
start_timeÚmax_local_stepsr/ ÚxÚyÚoutputr r r r r% s*
zclientProx.trainc C sD x>t | ¡ | j| j ¡ ƒD ]"\}}}|j ¡ |_|j ¡ |_qW d S )N)Úzipr
r r ÚdataÚclone)r r Ú new_paramZ global_paramÚparamr r r Úset_parameters5 s $ zclientProx.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r% r= Ú
__classcell__r r )r r r
s r ) ÚtorchÚnumpyr( r" r Útorch.nnr Ú flcore.optimizers.fedoptimizerr Úflcore.clients.clientbaser r r r r r Ú<module> s | 1,943 | Python | .py | 20 | 95.9 | 283 | 0.466216 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,712 | clientperavg.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientperavg.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)Ú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__© õN D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\clients\clientperavg.pyr s
zclientPerAvg.__init__c C sˆ | | jd ¡}t ¡ }| j | j¡ | j ¡ | j}| jrNt j
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�rt 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 ¡ | |¡}
| |
| ¡} | ¡ t| j ¡ |ƒD ]\} }
|
j ¡ | _�q"| jj| j d� q`qV| 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_stepsr4 Ú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 r2 r r3 r4 r r8 )r Z
testloaderZiter_testloaderr? r@ rA r r r r Útrain_one_stepN s2
zclientPerAvg.train_one_step)Ú__name__Ú
__module__Ú __qualname__r r$ rG Ú
__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,805 | Python | .py | 40 | 68.9 | 226 | 0.395155 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,713 | clientreppt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/clients/__pycache__/clientreppt.cpython-37.pyc | B
K´ccZ ã @ 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 )Ú clientREPPTc 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__© úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/clients/clientreppt.pyr s
zclientREPPT.__init__c C sT | ¡ }t ¡ }t | jj¡}| j | j¡ | j ¡ x| jj
¡ D ]
}d|_ qDW x| jj
¡ D ]
}d|_ q`W 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 } | j�rjtj d| d ¡} x | jj
¡ D ] }d|_ �qxW x | jj
¡ D ] }d|_ �q–W x | jj
¡ D ] }d|_ �q´W xÂt
| ƒD ]¶}x®t|ƒD ]¢\}\}}t|ƒtg ƒk�r|d | j¡|d< n | | j¡}| | j¡}| j�rJt dt tj ¡ ¡ ¡ | j ¡ | |¡} | | |¡}
|
¡ | j ¡ �qÜW �qÎW | 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ÚtimeÚcopyÚdeepcopyr
r ÚtoÚdeviceÚtrainr r Ú
requires_gradÚ predictorÚranger Ú enumerateÚtypeÚ
train_slowÚsleepÚnpÚabsÚrandomÚrandr Ú zero_gradr ÚbackwardÚstepÚ local_stepsÚrandintr ÚcpuÚtrain_time_costÚzipr
ÚwhereÚ
zeros_likeÚsum)r Ú trainloaderÚ
start_timeÚ
old_promptÚparamr6 ÚiÚxÚyÚoutputr Úmax_local_stepsÚ
new_promptÚ
diff_provalueÚ new_paramÚ old_paramÚdiff_pror r r r( st
zclientREPPT.trainc C s4 x.t | ¡ | jj ¡ ƒD ]\}}|j ¡ |_qW d S )N)r; r r
r ÚdataÚclone)r r rJ rK r r r Úset_parameters^ s zclientREPPT.set_parameters)Ú__name__Ú
__module__Ú __qualname__r r( rO Ú
__classcell__r r )r r r s
Hr )
r
Útorch.nnr Únumpyr0 r# Ú system.flcore.clients.clientbaser r$ r r r r r Ú<module> s | 2,710 | Python | .py | 44 | 60.113636 | 288 | 0.421447 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,714 | clientavg-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientavg-checkpoint.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,715 | clientditto-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientditto-checkpoint.py | import torch
import numpy as np
import time
import copy
import torch.nn as nn
from flcore.optimizers.fedoptimizer import PerturbedGradientDescent
from flcore.clients.clientbase import Client
import torch.nn.functional as F
from sklearn.preprocessing import label_binarize
from sklearn import metrics
# from utils.privacy import *
class clientDitto(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.mu = args.mu
self.plocal_steps = args.plocal_steps
self.pmodel = copy.deepcopy(self.model)
self.loss = nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.learning_rate)
self.poptimizer = PerturbedGradientDescent(
self.pmodel.parameters(), lr=self.learning_rate, mu=self.mu)
# # 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]}")
def ptrain(self):
trainloader = self.load_train_data()
start_time = time.time()
self.pmodel.to(self.device)
self.pmodel.train()
max_local_steps = self.plocal_steps
if self.train_slow:
max_local_steps = np.random.randint(1, max_local_steps // 2)
for step in range(max_local_steps):
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)
if self.train_slow:
time.sleep(0.1 * np.abs(np.random.rand()))
self.poptimizer.zero_grad()
output = self.pmodel(x)
loss = self.loss(output, y)
loss.backward()
self.poptimizer.step(self.model.parameters(), self.device)
self.pmodel.cpu()
self.train_time_cost['total_cost'] += time.time() - start_time
def test_metrics(self):
testloaderfull = self.load_test_data()
# self.model = self.load_model('model')
self.pmodel.to(self.device)
self.pmodel.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.pmodel(x)
test_acc += (torch.sum(torch.argmax(output, dim=1) == y)).item()
test_num += y.shape[0]
y_prob.append(F.softmax(output).detach().cpu().numpy())
y_true.append(label_binarize(y.detach().cpu().numpy(), classes=np.arange(self.num_classes)))
self.pmodel.cpu()
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_num, auc | 4,593 | Python | .py | 107 | 30.897196 | 108 | 0.550567 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,716 | clientpFedMe-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientpFedMe-checkpoint.py | import numpy as np
import time
import copy
import torch
import torch.nn as nn
from flcore.optimizers.fedoptimizer import pFedMeOptimizer
from flcore.clients.clientbase import Client
class clientpFedMe(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.lamda = args.lamda
self.K = args.K
self.personalized_learning_rate = args.p_learning_rate
# these parameters are for personalized federated learing.
self.local_params = copy.deepcopy(list(self.model.parameters()))
self.personalized_params = copy.deepcopy(list(self.model.parameters()))
self.loss = nn.CrossEntropyLoss()
self.optimizer = pFedMeOptimizer(
self.model.parameters(), lr=self.personalized_learning_rate, lamda=self.lamda)
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): # local update
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)
if self.train_slow:
time.sleep(0.1 * np.abs(np.random.rand()))
# K is number of personalized steps
for i in range(self.K):
self.optimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
# finding aproximate theta
self.personalized_params = self.optimizer.step(self.local_params, self.device)
# update local weight after finding aproximate theta
for new_param, localweight in zip(self.personalized_params, self.local_params):
localweight = localweight.to(self.device)
localweight.data = localweight.data - self.lamda * self.learning_rate * (localweight.data - new_param.data)
# self.model.cpu()
self.update_parameters(self.model, self.local_params)
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def set_parameters(self, model):
for new_param, old_param, local_param in zip(model.parameters(), self.model.parameters(), self.local_params):
old_param.data = new_param.data.clone()
local_param.data = new_param.data.clone()
def test_metrics_personalized(self):
testloaderfull = self.load_test_data()
self.update_parameters(self.model, self.personalized_params)
# self.model.to(self.device)
self.model.eval()
test_acc = 0
test_num = 0
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]
# self.model.cpu()
return test_acc, test_num
# def train_metrics_personalized(self):
# self.update_parameters(self.model, self.personalized_params)
# # self.model.to(self.device)
# self.model.eval()
# train_acc = 0
# train_num = 0
# loss = 0
# for x, y in trainloaderfull:
# 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_acc += (torch.sum(torch.argmax(output, dim=1) == y)).item()
# train_num += y.shape[0]
# loss += self.loss(output, y).item() * y.shape[0]
# # self.model.cpu()
# return train_acc, loss, train_num
| 4,350 | Python | .py | 94 | 35.308511 | 127 | 0.566912 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,717 | clientrep-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientrep-checkpoint.py | import torch
import torch.nn as nn
import numpy as np
import time
from system.flcore.clients.clientbase import Client
# from utils.privacy import *
class clientRep(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.poptimizer = torch.optim.SGD(self.model.predictor.parameters(), lr=self.learning_rate)
self.plocal_steps = args.plocal_steps
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.model.train()
for param in self.model.base.parameters():
param.requires_grad = False
for param in self.model.predictor.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()
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.predictor.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()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
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() | 2,827 | Python | .py | 63 | 32.095238 | 99 | 0.559867 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,718 | clientpt-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientpt-checkpoint.py | import torch
import torch.nn as nn
import numpy as np
import time
from system.flcore.clients.clientbase import Client
import copy
# 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.poptimizer = torch.optim.SGD(self.model.generator.parameters(), lr=self.learning_rate)
self.optimizer = torch.optim.SGD(self.model.base.parameters(), lr=self.learning_rate)
self.plocal_steps = args.plocal_steps
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()
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 = 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() | 3,248 | Python | .py | 72 | 33.291667 | 99 | 0.571745 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,719 | clientfomo-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientfomo-checkpoint.py | import torch
import torch.nn as nn
import numpy as np
import time
import copy
from flcore.clients.clientbase import Client
from torch.utils.data import DataLoader
from utils.data_utils import read_client_data
class clientFomo(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.num_clients = args.num_clients
self.old_model = copy.deepcopy(self.model)
self.received_ids = []
self.received_models = []
self.weight_vector = torch.zeros(self.num_clients, device=self.device)
self.loss = nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.learning_rate)
self.val_ratio = 0.2
self.train_samples = self.train_samples * (1-self.val_ratio)
def train(self):
trainloader, val_loader = self.load_train_data()
start_time = time.time()
self.aggregate_parameters(val_loader)
self.clone_model(self.model, self.old_model)
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 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)
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()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
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, is_train=True)
val_idx = -int(self.val_ratio*len(train_data))
val_data = train_data[val_idx:]
train_data = train_data[:val_idx]
trainloader = DataLoader(train_data, self.batch_size, drop_last=True, shuffle=True)
val_loader = DataLoader(val_data, self.batch_size, drop_last=self.has_BatchNorm, shuffle=True)
return trainloader, val_loader
def train_metrics(self):
trainloader, val_loader = 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 receive_models(self, ids, models):
self.received_ids = ids
self.received_models = models
def weight_cal(self, val_loader):
weight_list = []
L = self.recalculate_loss(self.old_model, val_loader)
for received_model in self.received_models:
params_dif = []
for param_n, param_i in zip(received_model.parameters(), self.old_model.parameters()):
params_dif.append((param_n - param_i).view(-1))
params_dif = torch.cat(params_dif)
weight_list.append((L - self.recalculate_loss(received_model, val_loader)) / (torch.norm(params_dif) + 1e-5))
# import torch.autograd.profiler as profiler
# with profiler.profile(profile_memory=True, record_shapes=True) as prof:
# self.weight_vector_update(weight_list)
# print(prof.key_averages().table(sort_by="cuda_memory_usage", row_limit=10))
# from pytorch_memlab import LineProfiler
# with LineProfiler(self.weight_vector_update(weight_list)) as prof:
# self.weight_vector_update(weight_list)
# prof.display()
self.weight_vector_update(weight_list)
return torch.tensor(weight_list)
# from pytorch_memlab import profile
# @profile
def weight_vector_update(self, weight_list):
# self.weight_vector = torch.zeros(self.num_clients, device=self.device)
# for w, id in zip(weight_list, self.received_ids):
# self.weight_vector[id] += w.clone()
self.weight_vector = np.zeros(self.num_clients)
for w, id in zip(weight_list, self.received_ids):
self.weight_vector[id] += w.item()
self.weight_vector = torch.tensor(self.weight_vector).to(self.device)
def recalculate_loss(self, new_model, val_loader):
L = 0
new_model.to(self.device)
for x, y in val_loader:
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
output = new_model(x)
loss = self.loss(output, y)
L += loss.item()
new_model.cpu()
return L / len(val_loader)
def add_parameters(self, w, received_model):
for param, received_param in zip(self.model.parameters(), received_model.parameters()):
param.data += received_param.data.clone() * w
def aggregate_parameters(self, val_loader):
weights = self.weight_scale(self.weight_cal(val_loader))
if len(weights) > 0:
for param in self.model.parameters():
param.data.zero_()
for w, received_model in zip(weights, self.received_models):
self.add_parameters(w, received_model)
def weight_scale(self, weights):
weights = torch.maximum(weights, torch.tensor(0))
w_sum = torch.sum(weights)
if w_sum > 0:
weights = [w/w_sum for w in weights]
return torch.tensor(weights)
else:
return torch.tensor([])
| 6,368 | Python | .py | 140 | 34.857143 | 121 | 0.596191 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,720 | clientper-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientper-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
class clientPer(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)
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()
self.optimizer.step()
# self.model.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def set_parameters(self, model):
for new_param, old_param in zip(model.parameters(), self.model.base.parameters()):
old_param.data = new_param.data.clone()
| 1,668 | Python | .py | 39 | 31.74359 | 90 | 0.573034 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,721 | clientbase-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientbase-checkpoint.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.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, 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, 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)
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,643 | Python | .py | 131 | 33.778626 | 108 | 0.586036 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,722 | clientdynpt-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientdynpt-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
# from utils.privacy import *
class clientDynPT(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)
self.alpha = args.alpha
self.global_model_vector = None
old_grad = copy.deepcopy(self.model)
old_grad = model_parameter_vector(old_grad)
self.old_grad = torch.zeros_like(old_grad)
self.poptimizer = torch.optim.SGD(self.model.generator.parameters(), lr=self.learning_rate)
self.optimizer = torch.optim.SGD(self.model.base.parameters(), lr=self.learning_rate)
self.plocal_steps = args.plocal_steps
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.old_grad = self.old_grad.to(self.device)
self.global_model_vector = self.global_model_vector.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()
max_local_steps = self.local_steps
for param in self.model.base.parameters():
param.requires_grad = True
for param in self.model.generator.parameters():
param.requires_grad = False
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)
if self.global_model_vector != None:
v1 = model_parameter_vector(self.model)
loss += self.alpha / 2 * torch.norm(v1 - self.global_model_vector, 2)
loss -= torch.dot(v1, self.old_grad)
loss.backward()
self.optimizer.step()
if self.global_model_vector != None:
v1 = model_parameter_vector(self.model).detach()
self.old_grad = self.old_grad - self.alpha * (v1 - self.global_model_vector)
self.model.cpu()
self.old_grad = self.old_grad.cpu()
self.global_model_vector = self.global_model_vector.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
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 = torch.sum(diff_pro)
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
return diff_provalue
#
# if self.privacy:
# res, DELTA = get_dp_params(self.optimizer)
# print(f"Client {self.id}", f"(ε = {res[0]:.2f}, δ = {DELTA}) for α = {res[1]}")
def set_parameters(self, model):
for new_param, old_param in zip(model.base.parameters(), self.model.base.parameters()):
old_param.data = new_param.data.clone()
self.global_model_vector = model_parameter_vector(model).detach().clone()
def model_parameter_vector(model):
param = [p.view(-1) for p in model.parameters()]
return torch.cat(param, dim=0) | 4,956 | Python | .py | 103 | 36.747573 | 99 | 0.583144 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,723 | clientbn-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientbn-checkpoint.py | import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
# from utils.privacy import *
class clientBN(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]}")
def set_parameters(self, model):
for (nn, np), (on, op) in zip(model.named_parameters(), self.model.named_parameters()):
if 'bn' not in nn:
op.data = np.data.clone() | 2,207 | Python | .py | 50 | 32.28 | 95 | 0.55298 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,724 | clientphp-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientphp-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
# from utils.privacy import *
class clientPHP(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)
self.mu = args.mu / args.global_rounds
self.lamda = args.lamda
self.model_s = copy.deepcopy(self.model)
for param in self.model_s.parameters():
param.requires_grad = False
# self.model_s.eval()
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.model_s.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) * (1 - self.lamda)
loss += MMD(self.model.base(x), self.model_s.base(x), 'rbf', self.device) * self.lamda
loss.backward()
self.optimizer.step()
self.model.cpu()
self.model_s.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def set_parameters(self, model, R):
mu = self.mu * R
for new_param, old_param in zip(model.parameters(), self.model_s.parameters()):
old_param.data = new_param.data.clone()
for new_param, old_param in zip(model.parameters(), self.model.parameters()):
old_param.data = new_param * (1 - mu) + old_param * mu
def MMD(x, y, kernel, device='cpu'):
"""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"
"""
xx, yy, zz = torch.mm(x, x.t()), torch.mm(y, y.t()), torch.mm(x, y.t())
rx = (xx.diag().unsqueeze(0).expand_as(xx))
ry = (yy.diag().unsqueeze(0).expand_as(yy))
dxx = rx.t() + rx - 2. * xx # Used for A in (1)
dyy = ry.t() + ry - 2. * yy # Used for B in (1)
dxy = rx.t() + ry - 2. * zz # Used for C in (1)
XX, YY, XY = (torch.zeros(xx.shape).to(device),
torch.zeros(xx.shape).to(device),
torch.zeros(xx.shape).to(device))
if kernel == "multiscale":
bandwidth_range = [0.2, 0.5, 0.9, 1.3]
for a in bandwidth_range:
XX += a**2 * (a**2 + dxx)**-1
YY += a**2 * (a**2 + dyy)**-1
XY += a**2 * (a**2 + dxy)**-1
if kernel == "rbf":
bandwidth_range = [10, 15, 20, 50]
for a in bandwidth_range:
XX += torch.exp(-0.5*dxx/a)
YY += torch.exp(-0.5*dyy/a)
XY += torch.exp(-0.5*dxy/a)
return torch.mean(XX + YY - 2. * XY) | 3,672 | Python | .py | 82 | 34.085366 | 102 | 0.555238 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,725 | clientreppt-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientreppt-checkpoint.py | import torch
import torch.nn as nn
import numpy as np
import time
from system.flcore.clients.clientbase import Client
import copy
# from utils.privacy import *
class clientREPPT(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.poptimizer = torch.optim.SGD(self.model.generator.parameters(), lr=self.learning_rate)
self.optimizer = torch.optim.SGD(self.model.base.parameters(), lr=self.learning_rate)
self.plocal_steps = args.plocal_steps
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 param in self.model.predictor.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()
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 param in self.model.predictor.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()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
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 = 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() | 3,562 | Python | .py | 78 | 33.974359 | 99 | 0.576168 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,726 | clientdyn-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientdyn-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
# from utils.privacy import *
class clientDyn(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)
self.alpha = args.alpha
self.global_model_vector = None
old_grad = copy.deepcopy(self.model)
old_grad = model_parameter_vector(old_grad)
self.old_grad = torch.zeros_like(old_grad)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.old_grad = self.old_grad.to(self.device)
self.global_model_vector = self.global_model_vector.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)
if self.global_model_vector != None:
v1 = model_parameter_vector(self.model)
loss += self.alpha/2 * torch.norm(v1 - self.global_model_vector, 2)
loss -= torch.dot(v1, self.old_grad)
loss.backward()
self.optimizer.step()
if self.global_model_vector != None:
v1 = model_parameter_vector(self.model).detach()
self.old_grad = self.old_grad - self.alpha * (v1 - self.global_model_vector)
self.model.cpu()
self.old_grad = self.old_grad.cpu()
self.global_model_vector= self.global_model_vector.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]}")
def set_parameters(self, model):
for new_param, old_param in zip(model.parameters(), self.model.parameters()):
old_param.data = new_param.data.clone()
self.global_model_vector = model_parameter_vector(model).detach().clone()
def model_parameter_vector(model):
param = [p.view(-1) for p in model.parameters()]
return torch.cat(param, dim=0) | 3,199 | Python | .py | 68 | 36.132353 | 93 | 0.587796 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,727 | clientproto-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientproto-checkpoint.py | from collections import defaultdict
import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
# from utils.privacy import *
class clientProto(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)
self.feature_dim = list(self.model.predictor.parameters())[0].shape[1]
self.protos = None
self.global_protos = None
self.loss_mse = nn.MSELoss()
self.lamda = args.lamda
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)
protos = defaultdict(list)
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()
rep = self.model.base(x)
output = self.model.predictor(rep)
loss = self.loss(output, y)
if self.global_protos != None:
proto_new = torch.zeros_like(rep)
for i, yy in enumerate(y):
y_c = yy.item()
proto_new[i, :] = self.global_protos[y_c].data
loss += self.loss_mse(proto_new, rep) * self.lamda
for i, yy in enumerate(y):
y_c = yy.item()
protos[y_c].append(rep[i, :].detach().data)
loss.backward()
self.optimizer.step()
# self.model.cpu()
# rep = self.model.base(x)
# print(torch.sum(rep!=0).item() / rep.numel())
# self.collect_protos()
self.protos = agg_func(protos)
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def set_protos(self, global_protos):
self.global_protos = copy.deepcopy(global_protos)
def collect_protos(self):
trainloader = self.load_train_data()
self.model.eval()
protos = defaultdict(list)
with torch.no_grad():
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()
rep = self.model.base(x)
for i, yy in enumerate(y):
y_c = yy.item()
protos[y_c].append(rep[i, :].detach().data)
self.protos = agg_func(protos)
def test_metrics(self, model=None):
testloader = self.load_test_data()
if model == None:
model = self.model
model.eval()
test_acc = 0
test_num = 0
with torch.no_grad():
for x, y in testloader:
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
rep = self.model.base(x)
output = float('inf') * torch.ones(y.shape[0], self.num_classes).to(self.device)
for i, r in enumerate(rep):
for j, pro in self.global_protos.items():
output[i, j] = self.loss_mse(r, pro)
test_acc += (torch.sum(torch.argmin(output, dim=1) == y)).item()
test_num += y.shape[0]
return test_acc, test_num, 0
# https://github.com/yuetan031/fedproto/blob/main/lib/utils.py#L205
def agg_func(protos):
"""
Returns the average of the weights.
"""
for [label, proto_list] in protos.items():
if len(proto_list) > 1:
proto = 0 * proto_list[0].data
for i in proto_list:
proto += i.data
protos[label] = proto / len(proto_list)
else:
protos[label] = proto_list[0]
return protos | 4,762 | Python | .py | 115 | 28.756522 | 96 | 0.519461 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,728 | clientmoon-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientmoon-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
import torch.nn.functional as F
from flcore.clients.clientbase import Client
# from utils.privacy import *
class clientMOON(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)
self.tau = args.tau
self.mu = args.mu
self.global_model = None
self.old_model = copy.deepcopy(self.model)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.global_model.to(self.device)
self.old_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()
rep = self.model.base(x)
output = self.model.predictor(rep)
loss = self.loss(output, y)
rep_old = self.old_model.base(x).detach()
rep_global = self.global_model.base(x).detach()
loss_con = - torch.log(torch.exp(F.cosine_similarity(rep, rep_global) / self.tau) / (torch.exp(F.cosine_similarity(rep, rep_global) / self.tau) + torch.exp(F.cosine_similarity(rep, rep_old) / self.tau)))
loss += self.mu * torch.mean(loss_con)
loss.backward()
if self.privacy:
dp_step(self.optimizer, i, len(trainloader))
else:
self.optimizer.step()
self.model.cpu()
self.global_model.cpu()
self.old_model.cpu()
self.old_model = copy.deepcopy(self.model)
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]}")
def set_parameters(self, model):
for new_param, old_param in zip(model.parameters(), self.model.parameters()):
old_param.data = new_param.data.clone()
self.global_model = model | 3,023 | Python | .py | 66 | 34.757576 | 219 | 0.574403 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,729 | clientperavg-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientperavg-checkpoint.py | import numpy as np
import torch
import time
import copy
import torch.nn as nn
from flcore.optimizers.fedoptimizer import PerAvgOptimizer
from flcore.clients.clientbase import Client
class clientPerAvg(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
# self.beta = args.beta
self.beta = self.learning_rate
self.loss = nn.CrossEntropyLoss()
self.optimizer = PerAvgOptimizer(self.model.parameters(), lr=self.learning_rate)
def train(self):
trainloader = self.load_train_data(self.batch_size*2)
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): # local update
for X, Y in trainloader:
temp_model = copy.deepcopy(list(self.model.parameters()))
# step 1
if type(X) == type([]):
x = [None, None]
x[0] = X[0][:self.batch_size].to(self.device)
x[1] = X[1][:self.batch_size]
else:
x = X[:self.batch_size].to(self.device)
y = Y[:self.batch_size].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()
# step 2
if type(X) == type([]):
x = [None, None]
x[0] = X[0][self.batch_size:].to(self.device)
x[1] = X[1][self.batch_size:]
else:
x = X[self.batch_size:].to(self.device)
y = Y[self.batch_size:].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()
# restore the model parameters to the one before first update
for old_param, new_param in zip(self.model.parameters(), temp_model):
old_param.data = new_param.data.clone()
self.optimizer.step(beta=self.beta)
# self.model.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def train_one_step(self):
testloader = self.load_test_data(self.batch_size)
iter_testloader = iter(testloader)
# self.model.to(self.device)
self.model.train()
# step 1
(x, y) = next(iter_testloader)
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
self.optimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
self.optimizer.step()
# step 2
(x, y) = next(iter_testloader)
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
self.optimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
self.optimizer.step(beta=self.beta)
# self.model.cpu()
| 3,719 | Python | .py | 91 | 28.758242 | 88 | 0.529787 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,730 | clientmtl-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientmtl-checkpoint.py | import torch
import torch.nn as nn
from flcore.clients.clientbase import Client
import numpy as np
import time
import math
import copy
class clientMTL(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.omega = None
self.W_glob = None
self.idx = 0
self.itk = args.itk
self.lamba = 1e-4
self.loss = nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.learning_rate, momentum=0.5)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
# self.model = self.load_model('model')
# 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 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)
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)
self.W_glob[:, self.idx] = flatten(self.model)
loss_regularizer = 0
loss_regularizer += self.W_glob.norm() ** 2
# for i in range(self.W_glob.shape[0] // self.itk):
# x = self.W_glob[i * self.itk:(i+1) * self.itk, :]
# loss_regularizer += torch.sum(torch.sum((x*self.omega), 1)**2)
loss_regularizer += torch.sum(torch.sum((self.W_glob*self.omega), 1)**2)
f = (int)(math.log10(self.W_glob.shape[0])+1) + 1
loss_regularizer *= 10 ** (-f)
loss += loss_regularizer
loss.backward()
self.optimizer.step()
# self.model.cpu()
# self.save_model(self.model, 'model')
self.omega = None
self.W_glob = None
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def receive_values(self, W_glob, omega, idx):
self.omega = torch.sqrt(omega[0][0])
self.W_glob = copy.deepcopy(W_glob)
self.idx = idx
def flatten(model):
state_dict = model.state_dict()
keys = state_dict.keys()
W = [state_dict[key].flatten() for key in keys]
return torch.cat(W) | 2,734 | Python | .py | 65 | 31.030769 | 102 | 0.549183 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,731 | clientapfl-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientapfl-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
class clientAPFL(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)
self.alpha = args.alpha
self.model_per = copy.deepcopy(self.model)
self.optimizer_per = torch.optim.SGD(self.model_per.parameters(), lr=self.learning_rate)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model_per.to(self.device)
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()
self.optimizer.step()
self.optimizer_per.zero_grad()
output_per = self.model_per(x)
loss_per = self.loss(output_per, y)
loss_per.backward()
self.optimizer_per.step()
self.alpha_update()
for lp, p in zip(self.model_per.parameters(), self.model.parameters()):
lp.data = (1 - self.alpha) * p + self.alpha * lp
self.model.cpu()
self.model_per.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
# https://github.com/MLOPTPSU/FedTorch/blob/b58da7408d783fd426872b63fbe0c0352c7fa8e4/fedtorch/comms/utils/flow_utils.py#L240
def alpha_update(self):
grad_alpha = 0
for l_params, p_params in zip(self.model.parameters(), self.model_per.parameters()):
dif = p_params.data - l_params.data
grad = self.alpha * p_params.grad.data + (1-self.alpha) * l_params.grad.data
grad_alpha += dif.view(-1).T.dot(grad.view(-1))
grad_alpha += 0.02 * self.alpha
self.alpha = self.alpha - self.learning_rate * grad_alpha
self.alpha = np.clip(self.alpha.item(), 0.0, 1.0) | 2,786 | Python | .py | 59 | 35.627119 | 128 | 0.58352 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,732 | clientt-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientt-checkpoint.py | import torch
import torch.nn as nn
import numpy as np
import time
from system.flcore.clients.clientbase import Client
import copy
# from utils.privacy import *
class clientT(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.poptimizer = torch.optim.SGD(self.model.generator.parameters(), lr=self.learning_rate)
self.optimizer = torch.optim.SGD(self.model.base.parameters(), lr=self.learning_rate)
self.ser_para()
self.plocal_steps = args.plocal_steps
def ser_para(self):
torch.manual_seed(self.id)
self.model.generator.pad_down.data = torch.rand_like(self.model.generator.pad_down.data )
self.model.generator.pad_left.data = torch.rand_like(self.model.generator.pad_left.data)
self.model.generator.pad_right.data = torch.rand_like(self.model.generator.pad_right.data)
self.model.generator.pad_up.data = torch.rand_like(self.model.generator.pad_up.data)
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()
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() | 2,962 | Python | .py | 61 | 38.245902 | 99 | 0.619229 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,733 | clientbabu-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientbabu-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
class clientBABU(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.fine_tuning_steps = args.fine_tuning_steps
for param in self.model.predictor.parameters():
param.requires_grad = False
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()
self.optimizer.step()
# self.model.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
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 fine_tune(self, which_module=['base', 'predictor']):
trainloader = self.load_train_data()
self.model.train()
if 'predictor' in which_module:
for param in self.model.predictor.parameters():
param.requires_grad = True
if 'base' not in which_module:
for param in self.model.predictor.parameters():
param.requires_grad = False
for step in range(self.fine_tuning_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)
self.optimizer.zero_grad()
output = self.model(x)
loss = self.loss(output, y)
loss.backward()
self.optimizer.step()
| 2,762 | Python | .py | 63 | 31.285714 | 93 | 0.556186 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,734 | clientrod-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientrod-checkpoint.py | import copy
import torch
import torch.nn as nn
import numpy as np
import time
from flcore.clients.clientbase import Client
import torch.nn.functional as F
from sklearn.preprocessing import label_binarize
from sklearn import metrics
class clientROD(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)
self.pred = copy.deepcopy(self.model.predictor)
self.opt_pred = torch.optim.SGD(self.pred.parameters(), lr=self.learning_rate)
self.sample_per_class = torch.zeros(self.num_classes)
trainloader = self.load_train_data()
for x, y in trainloader:
for yy in y:
self.sample_per_class[yy.item()] += 1
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.pred.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)
rep = self.model.base(x)
out_g = self.model.predictor(rep)
loss_bsm = balanced_softmax_loss(y, out_g, self.sample_per_class)
self.optimizer.zero_grad()
loss_bsm.backward()
self.optimizer.step()
out_p = self.pred(rep.detach())
loss = self.loss(out_g.detach() + out_p, y)
self.opt_pred.zero_grad()
loss.backward()
self.opt_pred.step()
self.model.cpu()
self.pred.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def test_metrics(self, model=None):
testloader = self.load_test_data()
if model == None:
model = self.model
self.model.to(self.device)
self.pred.to(self.device)
model.eval()
test_acc = 0
test_num = 0
y_prob = []
y_true = []
with torch.no_grad():
for x, y in testloader:
if type(x) == type([]):
x[0] = x[0].to(self.device)
else:
x = x.to(self.device)
y = y.to(self.device)
rep = self.model.base(x)
out_g = self.model.predictor(rep)
out_p = self.pred(rep.detach())
output = out_g.detach() + out_p
test_acc += (torch.sum(torch.argmax(output, dim=1) == y)).item()
test_num += y.shape[0]
y_prob.append(F.softmax(output).detach().cpu().numpy())
nc = self.num_classes
if self.num_classes == 2:
nc += 1
lb = label_binarize(y.detach().cpu().numpy(), classes=np.arange(nc))
if self.num_classes == 2:
lb = lb[:, :2]
y_true.append(lb)
self.model.cpu()
self.pred.cpu()
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_num, auc
# https://github.com/jiawei-ren/BalancedMetaSoftmax-Classification
def balanced_softmax_loss(labels, logits, sample_per_class, reduction="mean"):
"""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.
"""
spc = sample_per_class.type_as(logits)
spc = spc.unsqueeze(0).expand(logits.shape[0], -1)
logits = logits + spc.log()
loss = F.cross_entropy(input=logits, target=labels, reduction=reduction)
return loss
| 4,529 | Python | .py | 106 | 31.443396 | 88 | 0.563661 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,735 | clientprox-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientprox-checkpoint.py | import torch
import numpy as np
import time
import copy
import torch.nn as nn
from flcore.optimizers.fedoptimizer import PerturbedGradientDescent
from flcore.clients.clientbase import Client
class clientProx(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.mu = args.mu
self.global_params = copy.deepcopy(list(self.model.parameters()))
self.loss = nn.CrossEntropyLoss()
self.optimizer = PerturbedGradientDescent(
self.model.parameters(), lr=self.learning_rate, mu=self.mu)
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 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)
# 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.global_params, self.device)
self.model.cpu()
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def set_parameters(self, model):
for new_param, global_param, param in zip(model.parameters(), self.global_params, self.model.parameters()):
global_param.data = new_param.data.clone()
param.data = new_param.data.clone()
| 1,947 | Python | .py | 44 | 34.613636 | 115 | 0.59651 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,736 | clientamp-checkpoint.py | hkgdifyu_pFedPT/system/flcore/clients/.ipynb_checkpoints/clientamp-checkpoint.py | import torch
import torch.nn as nn
from flcore.clients.clientbase import Client
import numpy as np
import time
import copy
class clientAMP(Client):
def __init__(self, args, id, train_samples, test_samples, **kwargs):
super().__init__(args, id, train_samples, test_samples, **kwargs)
self.alphaK = args.alphaK
self.lamda = args.lamda
self.client_u = copy.deepcopy(self.model)
self.loss = nn.CrossEntropyLoss()
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=self.learning_rate)
def train(self):
trainloader = self.load_train_data()
start_time = time.time()
self.model.to(self.device)
self.client_u.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 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)
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)
params = weight_flatten(self.model)
params_ = weight_flatten(self.client_u)
sub = params - params_
loss += self.lamda/self.alphaK/2 * torch.dot(sub, sub)
loss.backward()
self.optimizer.step()
self.model.cpu()
self.client_u.cpu()
del trainloader
# print(torch.dot(sub, sub))
self.train_time_cost['num_rounds'] += 1
self.train_time_cost['total_cost'] += time.time() - start_time
def set_parameters(self, model, coef_self):
for new_param, old_param in zip(model.parameters(), self.client_u.parameters()):
old_param.data = (new_param.data + coef_self * old_param.data).clone()
def weight_flatten(model):
params = []
for u in model.parameters():
params.append(u.view(-1))
params = torch.cat(params)
return params
| 2,315 | Python | .py | 56 | 30.660714 | 88 | 0.576629 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,737 | models.py | hkgdifyu_pFedPT/system/flcore/trainmodel/models.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import logging
from functools import partial
from collections import OrderedDict
from transformers import ViTImageProcessor, ViTForImageClassification
import numpy as np
from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
from timm.models.layers import StdConv2dSame, DropPath, to_2tuple, trunc_normal_
batch_size = 16
class LocalModel(nn.Module):
def __init__(self, base, predictor):
super(LocalModel, self).__init__()
self.base = base
self.predictor = predictor
def forward(self, x):
out = self.base(x)
out = self.predictor(out)
return out
class LocalModel_pt(nn.Module):
def __init__(self, generator, base):
super(LocalModel_pt, self).__init__()
self.generator = generator
self.base = base
def forward(self, x):
out = self.generator(x)
out = self.base(out)
return out
class FedAvgCNN(nn.Module):
def __init__(self, in_features=1, num_classes=10, dim=1024):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_features,
32,
kernel_size=5,
padding=0,
stride=1,
bias=True),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=(2, 2))
)
self.conv2 = nn.Sequential(
nn.Conv2d(32,
64,
kernel_size=5,
padding=0,
stride=1,
bias=True),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=(2, 2))
)
self.fc1 = nn.Sequential(
nn.Linear(dim, 512),
nn.ReLU(inplace=True)
)
self.fc = nn.Linear(512, num_classes)
def forward(self, x):
out = self.conv1(x)
out = self.conv2(out)
out = torch.flatten(out, 1)
out = self.fc1(out)
out = self.fc(out)
return out
# ====================================================================================================================
def init_weights(m):
classname = m.__class__.__name__
if classname.find('Conv2d') != -1 or classname.find('ConvTranspose2d') != -1:
nn.init.kaiming_uniform_(m.weight)
nn.init.zeros_(m.bias)
elif classname.find('BatchNorm') != -1:
nn.init.normal_(m.weight, 1.0, 0.02)
nn.init.zeros_(m.bias)
elif classname.find('Linear') != -1:
nn.init.xavier_normal_(m.weight)
nn.init.zeros_(m.bias)
class PadPrompter(nn.Module):
def __init__(self,inchanel = 1,pad_size=1,image_size=28,args =None):
super(PadPrompter, self).__init__()
pad_size = pad_size
image_size = image_size
self.args = args
self.inchanel =inchanel
self.base_size = image_size - pad_size*2
self.pad_up = nn.Parameter(torch.randn([1, self.inchanel, pad_size, image_size]))
self.pad_down = nn.Parameter(torch.randn([1, self.inchanel, pad_size, image_size]))
self.pad_left = nn.Parameter(torch.randn([1, self.inchanel, image_size - pad_size*2, pad_size]))
self.pad_right = nn.Parameter(torch.randn([1,self.inchanel, image_size - pad_size*2, pad_size]))
def forward(self, x):
base = torch.zeros(1, self.inchanel, self.base_size, self.base_size).to(self.args.device)
prompt = torch.cat([self.pad_left, base, self.pad_right], dim=3)
prompt = torch.cat([self.pad_up, prompt, self.pad_down], dim=2)
prompt = torch.cat(x.size(0) * [prompt])
return x + prompt
# ====================================================================================================================
class PatchEmbed(nn.Module): # PatchEmbed from timm
"""
Image to Patch Embedding
CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
img_size = to_2tuple(img_size)
patch_size = to_2tuple(patch_size)
num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
self.img_size = img_size
self.patch_size = patch_size
self.num_patches = num_patches
self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
def forward(self, x):
B, C, H, W = x.shape
# FIXME look at relaxing size constraints
assert H == self.img_size[0] and W == self.img_size[1], \
f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
# CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
x = self.proj(x).flatten(2).transpose(1, 2)
# x: (B, 14*14, 768)
return x
class FFN(nn.Module): # Mlp from timm
"""
FFN (from timm)
:param in_features:
:param hidden_features:
:param out_features:
:param act_layer:
:param drop:
"""
def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
self.fc1 = nn.Linear(in_features, hidden_features)
self.act = act_layer()
self.fc2 = nn.Linear(hidden_features, out_features)
self.drop = nn.Dropout(drop)
def forward(self, x):
x = self.fc1(x)
x = self.act(x)
x = self.drop(x)
x = self.fc2(x)
x = self.drop(x)
return x
# MHSA
class Attention(nn.Module): # qkv Transform + MSA(MHSA) (Attention from timm)
"""
qkv Transform + MSA(MHSA) (from timm)
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim=CNN feature dim, because the patch size is 1x1
:param num_heads:
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param attn_drop: dropout rate after MHSA
:param proj_drop:
"""
def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
# NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
self.scale = qk_scale or head_dim ** -0.5
self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
self.attn_drop = nn.Dropout(attn_drop)
self.proj = nn.Linear(dim, dim)
self.proj_drop = nn.Dropout(proj_drop)
def forward(self, x):
# input x.shape = batch, patch_number, patch_dim
batch, patch_number, patch_dim = x.shape
# mlp transform + head split [B, Pn, D] -> [B, Pn, 3D] -> [B, Pn, 3, H, D/H] -> [3, B, H, Pn, D/H]
qkv = self.qkv(x).reshape(batch, patch_number, 3, self.num_heads, patch_dim //
self.num_heads).permute(2, 0, 3, 1, 4)
# 3 [B, H, Pn, D/H]
q, k, v = qkv[0], qkv[1], qkv[2]
# [B, H, Pn, D/H] -> [B, H, Pn, D/H]
attn = (q @ k.transpose(-2, -1)) * self.scale
attn = attn.softmax(dim=-1)
attn = self.attn_drop(attn) # Dropout
# head fusion: [B, H, Pn, D/H] -> [B, Pn, H, D/H] -> [B, Pn, D]
x = (attn @ v).transpose(1, 2).reshape(batch, patch_number, patch_dim)
x = self.proj(x)
x = self.proj_drop(x) # mlp
# output x.shape = batch, patch_number, patch_dim
return x
# Encoder_Block
class Block(nn.Module): # teansformer Block from timm
def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
"""
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim
:param num_heads:
:param mlp_ratio: FFN
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param drop:
:param attn_drop: dropout rate after Attention
:param drop_path: dropout rate after sd
:param act_layer: FFN act
:param norm_layer: Pre Norm
"""
super().__init__()
# Pre Norm
self.norm1 = norm_layer(dim) # Transformer used the nn.LayerNorm
self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop,
proj_drop=drop)
# NOTE from timm: drop path for stochastic depth, we shall see if this is better than dropout here
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() # stochastic depth
# Add & Norm
self.norm2 = norm_layer(dim)
# FFN
mlp_hidden_dim = int(dim * mlp_ratio)
self.mlp = FFN(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
def forward(self, x):
# MHSA + Res_connection
x = x + self.drop_path(self.attn(self.norm1(x)))
# FFN + Res_connection
x = x + self.drop_path(self.mlp(self.norm2(x)))
return x
class VisionTransformer(nn.Module): # From timm
"""
Vision Transformer
A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
- https://arxiv.org/abs/2010.11929
"""
def __init__(self, img_size=32, patch_size=4, in_chans=3, num_classes=10, embed_dim=128, depth=8,
num_heads=8, mlp_ratio=2., qkv_bias=True, representation_size=None, drop_rate=0., attn_drop_rate=0.,
drop_path_rate=0., embed_layer=PatchEmbed, norm_layer=None, act_layer=None):
"""
Args:
img_size (int, tuple): input image size
patch_size (int, tuple): patch size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (int): embedding dimension
depth (int): depth of transformer
num_heads (int): number of attention heads
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
embed_layer (nn.Module): patch embedding layer
norm_layer: (nn.Module): normalization layer
"""
super().__init__()
self.num_classes = num_classes
self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
self.num_tokens = 1
norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
act_layer = act_layer or nn.GELU
self.patch_embed = embed_layer(
img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
num_patches = self.patch_embed.num_patches
# Embedding tokens
self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
self.pos_drop = nn.Dropout(p=drop_rate)
# Stochastic Depth Decay rule
dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
# Encoders
self.blocks = nn.Sequential(*[
Block(dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, drop=drop_rate,
attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, act_layer=act_layer)
for i in range(depth)])
# last norm
self.norm = norm_layer(embed_dim)
# Representation layer
if representation_size:
self.num_features = representation_size
self.pre_logits = nn.Sequential(OrderedDict([
('fc', nn.Linear(embed_dim, representation_size)),
('act', nn.Tanh())
]))
else:
self.pre_logits = nn.Identity()
# Classifier head(s)
self.fc = nn.Linear(self.num_features, self.num_classes) if self.num_classes > 0 else nn.Identity()
self.head_dist = None
def forward_features(self, x):
x = self.patch_embed(x)
# print(x.shape,self.pos_embed.shape)
cls_token = self.cls_token.expand(x.shape[0], -1, -1)
x = torch.cat((cls_token, x), dim=1)
x = self.pos_drop(x + self.pos_embed)
x = self.blocks(x)
x = self.norm(x)
return x
def forward(self, x):
x = self.forward_features(x)
x = self.pre_logits(x[:, 0]) # use cls token for cls head [B,1,768]
x = self.fc(x)
return x
| 13,249 | Python | .py | 295 | 35.677966 | 118 | 0.577847 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,738 | bilstm.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/bilstm.cpython-37.pyc | B
É:ccÁ ã @ s* d dl Z d dl mZ G dd„ dejƒZdS )é N)Únnc s. e Zd Zd ‡ fdd„ Zdd„ Zdd„ Z‡ ZS )
ÚBiLSTM_TextClassificationFNc sú t t| ƒ ¡ || _|| _|| _|| _|| _|| _|| _ | | _
|| _ |
d k rbt j
t |
¡¡| _nt
| j| j ¡| _t j| jd�| _| j
r´t | jd | jd ¡| _t j| j d�| _t j| j | j| j|dd�| _t j| jd�| _t | jd | j¡| _d S )N)Úpé é T)ÚdropoutÚ
bidirectional)Úsuperr Ú__init__Ú
input_sizeÚ hidden_sizeÚ output_sizeÚ
num_layersÚembedding_dropoutÚ lstm_dropoutÚattention_dropoutÚ attentionÚembedding_lengthr Ú EmbeddingÚfrom_pretrainedÚtorchÚtensorÚword_embeddingsÚDropoutÚembedding_dropout_layerÚLinearÚattention_layerÚattention_dropout_layerÚLSTMÚ
lstm_layerÚlstm_dropout_layerÚ output_layer) Úselfr r r
r r r r r r Zembedding_weights)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/trainmodel/bilstm.pyr
s*
z"BiLSTM_TextClassification.__init__c
C s¬ | d¡}t ||¡ d¡}g }xZt|ƒD ]N\}}t || d |… d¡} t | d¡||d |…d d …f ¡}
| |
¡ q*W t t |d¡|fd¡} | | ¡} |
| ¡} | S )Nr r é ) Ú unsqueezer ÚbmmÚsqueezeÚ enumerateÚsoftmaxÚmatmulÚappendÚcatr r )
r" Z lstm_outputÚstateÚseq_lensÚhiddenZ attn_weightsZ new_hiddensÚiÚseq_lenZsoft_attn_weightsZ
new_hiddenZ
concat_hiddenZ
output_hiddenr$ r$ r% Úattention_forward" s
$
z+BiLSTM_TextClassification.attention_forwardc sê |\}}t |ƒ}| |¡}| |¡}t | jd || jf¡jdd�}t | jd || jf¡jdd�}| ddd¡}| |||f¡\‰ \}}ˆ ddd¡‰ tj
‡ fdd„t |ƒD ƒdd�} | | ¡} | j
rØ| ˆ | |¡‰ n| ‰ | ˆ ¡}
|
S ) Nr Úcuda)Údevicer& r c s, g | ]$\}}ˆ ||d dd…f d¡‘qS )r& Nr )r' )Ú.0r2 r3 )Úoutputr$ r% ú
<listcomp>J s z5BiLSTM_TextClassification.forward.<locals>.<listcomp>)Údim)Úlenr r r Úzerosr r ÚtoÚpermuter r. r* r r r4 r! ) r" ÚxZ input_seqr0 Ú
batch_sizeZh_0Zc_0Zfinal_hidden_stateZfinal_cell_stater/ Úlogitsr$ )r8 r% Úforward8 s
z!BiLSTM_TextClassification.forward)FN)Ú__name__Ú
__module__Ú __qualname__r
r4 rB Ú
__classcell__r$ r$ )r# r% r s r )r r ÚModuler r$ r$ r$ r% Ú<module> s | 2,663 | Python | .py | 30 | 87.7 | 247 | 0.465452 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,739 | vit.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/vit.cpython-38.pyc | U
”jfc7 ã @ s– d dl Z d dl mZ d dlmZmZ d dlmZ dd„ ZG dd„ dejƒZ G d d
„ d
ejƒZ
G d d „ d ejƒZ G d
d„ dejƒZ G dd„ dejƒZ
dS )é N)Únn)Ú rearrangeÚrepeat)Ú Rearrangec C s t | tƒr| S | | fS ©N)Ú
isinstanceÚtuple©Út© r õH D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\trainmodel\vit.pyÚpair s r
c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚPreNormc s t ƒ ¡ t |¡| _|| _d S r )ÚsuperÚ__init__r Ú LayerNormÚnormÚfn)ÚselfÚdimr ©Ú __class__r r r s
zPreNorm.__init__c K s | j | |¡f|�S r )r r )r ÚxÚkwargsr r r Úforward s zPreNorm.forward©Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú FeedForwardç c sB t ƒ ¡ t t ||¡t ¡ t |¡t ||¡t |¡¡| _d S r )r r r Ú
SequentialÚLinearÚGELUÚDropoutÚnet)r r Ú
hidden_dimÚdropoutr r r r s
ûzFeedForward.__init__c C s
| |¡S r )r& )r r r r r r s zFeedForward.forward)r! r r r r r r s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú Attentioné é@ çš™™™™™¹?c s„ t ƒ ¡ || }|dko ||k }|| _|d | _tjdd�| _tj||d dd�| _|rvt t ||¡t
|¡¡nt ¡ | _ d S )Né g à¿éÿÿÿÿ©r é F)Úbias)
r r ÚheadsÚscaler ÚSoftmaxÚattendr# Úto_qkvr" r% ÚIdentityÚto_out)r r r2 Údim_headr( Z inner_dimZ project_outr r r r $ s
ı
şızAttention.__init__c sp ˆ |¡jddd�}t‡ fdd„|ƒ\}}}t || dd¡¡ˆ j }ˆ |¡}t ||¡}t|dƒ}ˆ |¡S )Nr0 r. r/ c s t | dˆ jd�S )Nzb n (h d) -> b h n d)Úh)r r2 r ©r r r Ú<lambda>6 ó z#Attention.forward.<locals>.<lambda>éşÿÿÿzb h n d -> b n (h d))
r6 ÚchunkÚmapÚtorchÚmatmulÚ transposer3 r5 r r8 ) r r ÚqkvÚqÚkÚvÚdotsÚattnÚoutr r; r r 4 s
zAttention.forward)r* r+ r, r r r r r r) # s r) c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú Transformerr! c
s` t ƒ ¡ t g ¡| _t|ƒD ]<}| j t t|t||||d�ƒt|t |||d�ƒg¡¡ q d S )N)r2 r9 r( )r( )
r r r Ú
ModuleListÚlayersÚrangeÚappendr r) r )r r Údepthr2 r9 Úmlp_dimr( Ú_r r r r I s
şzTransformer.__init__c C s8 d}| j D ](\}}|d7 }||ƒ| }||ƒ| }q
|S )Nr r- )rM )r r ÚllrI Úffr r r r Q s zTransformer.forward)r! r r r r r rK H s rK c sJ e Zd Zddddddœ‡ fdd„
Zdd „ Zd
d „ Zd d
„ Zdd„ Z‡ ZS )ÚViTÚclsr0 r+ r! )ÚpoolÚchannelsr9 r( Ú emb_dropoutc s t ƒ ¡ t|ƒ\}
}t|ƒ\}}|
| dkr:|| dksBtdƒ‚|
| || }| | | }|dksntdƒ‚t td||d�t ||¡¡| _t t
d|d |¡¡| _ t t
dd|¡¡| _
t | ¡| _t||||
|| ƒ| _|| _t ¡ | _t |¡| _t ||¡| _d S )Nr z5Image dimensions must be divisible by the patch size.> rV Úmeanz?pool type must be either cls (cls token) or mean (mean pooling)z&b c (h p1) (w p2) -> b (h w) (p1 p2 c))Úp1Úp2r- )r r r
ÚAssertionErrorr r" r r# Úto_patch_embeddingÚ ParameterrA ÚrandnÚ
pos_embeddingÚ cls_tokenr% r( rK Ú transformerrW r7 Ú to_latentr r Úfc)r Ú
image_sizeÚ
patch_sizeÚ num_classesr rP r2 rQ rW rX r9 r( rY Ú image_heightÚ image_widthZ patch_heightZ patch_widthÚ num_patchesÚ patch_dimr r r r Z s&
ş
z ViT.__init__c C s² | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}| j dkr€|j
dd�n|d d …df }| |¡}| |¡}|
|¡}|S ©Nú() n d -> b n d©Úbr- r/ rZ r )r^ Úshaper rb rA Úcatra r( rc rW rZ rd r re ©r Úimgr rp ÚnrR Ú
cls_tokensr r r r w s
&
z ViT.forwardc C s� | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}| j dkr€|j
dd�n|d d …df }| |¡}|S rm ) r^ rq r rb rA rr ra r( rc rW rZ rd rs r r r Úproduce_feature‡ s
&
zViT.produce_featurec C sn | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}|S ©Nrn ro r- r/ © r^ rq r rb rA rr ra r( rc rs r r r Ú cal_feature— s
zViT.cal_featurec C sn | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}|S rx ry rs r r r Ú Show_detail¤ s
zViT.Show_detail) r r r r r rw rz r{ r r r r r rU Y s
rU )rA r Zeinopsr r Zeinops.layers.torchr r
ÚModuler r r) rK rU r r r r Ú<module> s
% | 5,881 | Python | .py | 56 | 103.875 | 448 | 0.353072 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,740 | vit.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/vit.cpython-37.pyc | B
Ƭdc7 ã @ s– d dl Z d dl mZ d dlmZmZ d dlmZ dd„ ZG dd„ dejƒZ G d d
„ d
ejƒZ
G d d „ d ejƒZ G d
d„ dejƒZ G dd„ dejƒZ
dS )é N)Únn)Ú rearrangeÚrepeat)Ú Rearrangec C s t | tƒr| S | | fS )N)Ú
isinstanceÚtuple)Út© r úC/root/autodl-tmp/PFL-Non-IID-master/system/flcore/trainmodel/vit.pyÚpair s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚPreNormc s t ƒ ¡ t |¡| _|| _d S )N)ÚsuperÚ__init__r Ú LayerNormÚnormÚfn)ÚselfÚdimr )Ú __class__r r
r s
zPreNorm.__init__c K s | j | |¡f|ŽS )N)r r )r ÚxÚkwargsr r r
Úforward s zPreNorm.forward)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r )r r
r s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú FeedForwardç c sB t ƒ ¡ t t ||¡t ¡ t |¡t ||¡t |¡¡| _d S )N)r
r r Ú
SequentialÚLinearÚGELUÚDropoutÚnet)r r Ú
hidden_dimÚdropout)r r r
r s
zFeedForward.__init__c C s
| |¡S )N)r" )r r r r r
r s zFeedForward.forward)r )r r r r r r r r )r r
r s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú Attentioné é@ çš™™™™™¹?c s„ t ƒ ¡ || }|dko ||k }|| _|d | _tjdd�| _tj||d dd�| _|rvt t ||¡t
|¡¡nt ¡ | _ d S )Né g à¿éÿÿÿÿ)r é F)Úbias)
r
r ÚheadsÚscaler ÚSoftmaxÚattendr Úto_qkvr r! ÚIdentityÚto_out)r r r- Údim_headr$ Z inner_dimZ project_out)r r r
r $ s
zAttention.__init__c sp ˆ |¡jddd�}t‡ fdd„|ƒ\}}}t || dd¡¡ˆ j }ˆ |¡}t ||¡}t|dƒ}ˆ |¡S )Nr+ r* )r c s t | dˆ jd�S )Nzb n (h d) -> b h n d)Úh)r r- )r )r r r
Ú<lambda>6 ó z#Attention.forward.<locals>.<lambda>éþÿÿÿzb h n d -> b n (h d))
r1 ÚchunkÚmapÚtorchÚmatmulÚ transposer. r0 r r3 ) r r ÚqkvÚqÚkÚvÚdotsÚattnÚoutr )r r
r 4 s
zAttention.forward)r& r' r( )r r r r r r r r )r r
r% # s r% c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú Transformerç c
sd t ƒ ¡ t g ¡| _xHt|ƒD ]<}| j t t|t||||d�ƒt|t |||d�ƒg¡¡ q W d S )N)r- r4 r$ )r$ )
r
r r Ú
ModuleListÚlayersÚrangeÚappendr r% r )r r Údepthr- r4 Úmlp_dimr$ Ú_)r r r
r I s
zTransformer.__init__c C s< d}x2| j D ](\}}|d7 }||ƒ| }||ƒ| }q W |S )Nr r) )rH )r r ÚllrC Úffr r r
r Q s zTransformer.forward)rF )r r r r r r r r )r r
rE H s rE c sJ e Zd Zddddddœ‡ fdd„
Zdd „ Zd
d „ Zd d
„ Zdd„ Z‡ ZS )ÚViTÚclsr+ r' g )ÚpoolÚchannelsr4 r$ Ú emb_dropoutc s t ƒ ¡ t|ƒ\}
}t|ƒ\}}|
| dkr:|| dksBtdƒ‚|
| || }| | | }|dksntdƒ‚t td||d�t ||¡¡| _t t
d|d |¡¡| _ t t
dd|¡¡| _
t | ¡| _t||||
|| ƒ| _|| _t ¡ | _t |¡| _t ||¡| _d S )Nr z5Image dimensions must be divisible by the patch size.> ÚmeanrQ z?pool type must be either cls (cls token) or mean (mean pooling)z&b c (h p1) (w p2) -> b (h w) (p1 p2 c))Úp1Úp2r) )r
r r ÚAssertionErrorr r r r Úto_patch_embeddingÚ Parameterr; ÚrandnÚ
pos_embeddingÚ cls_tokenr! r$ rE Ú transformerrR r2 Ú to_latentr r Úfc)r Ú
image_sizeÚ
patch_sizeÚ num_classesr rK r- rL rR rS r4 r$ rT Ú image_heightÚ image_widthZ patch_heightZ patch_widthÚ num_patchesÚ patch_dim)r r r
r Z s$
z ViT.__init__c C s² | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}| j dkr€|j
dd�n|d d …df }| |¡}| |¡}|
|¡}|S )Nz() n d -> b n d)Úbr) )r rU r )rY Úshaper r] r; Úcatr\ r$ r^ rR rU r_ r r` )r Úimgr rh ÚnrM Ú
cls_tokensr r r
r w s
&
z ViT.forwardc C sž | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}| j dkr€|j
dd�n|d d …df }| |¡}|S )Nz() n d -> b n d)rh r) )r rU r ) rY ri r r] r; rj r\ r$ r^ rR rU r_ )r rk r rh rl rM rm r r r
Úproduce_feature‡ s
&
zViT.produce_featurec C sn | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}|S )Nz() n d -> b n d)rh r) )r ) rY ri r r] r; rj r\ r$ r^ )r rk r rh rl rM rm r r r
Ú cal_feature— s
zViT.cal_featurec C sn | |¡}|j\}}}t| jd|d�}tj||fdd�}|| jd d …d |d …f 7 }| |¡}| |¡}|S )Nz() n d -> b n d)rh r) )r ) rY ri r r] r; rj r\ r$ r^ )r rk r rh rl rM rm r r r
Ú Show_detail¤ s
zViT.Show_detail) r r r r r rn ro rp r r r )r r
rP Y s
rP )r; r Zeinopsr r Zeinops.layers.torchr r ÚModuler r r% rE rP r r r r
Ú<module> s
% | 6,118 | Python | .py | 73 | 82.69863 | 448 | 0.349983 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,741 | models.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/models.cpython-38.pyc | U
>Nÿcbl ã @ s d dl Z d dlmZ d dlm mZ d dlZd dlZd dlm Z d dl
m Z d dl Z
d dlmZmZ d dlmZmZmZmZ dZG dd„ dejƒZG d d
„ d
ejƒZG d d „ d ejƒZG d
d„ dejƒZG dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ dd„ Z!G dd „ d ejƒZ"G d d „ d ejƒZ#G d d „ d ejƒZ$G d!d"„ d"ejƒZ%G d#d$„ d$ejƒZ&G d%d&„ d&ejƒZ'G d'd(„ d(ejƒZ(G d)d*„ d*ejƒZ)G d+d,„ d,ejƒZ*G d-d.„ d.ejƒZ+G d/d0„ d0ejƒZ,G d1d2„ d2ejƒZ-dS )3é N)Úpartial)Ú OrderedDict)ÚIMAGENET_DEFAULT_MEANÚIMAGENET_DEFAULT_STD)Ú
StdConv2dSameÚDropPathÚ to_2tupleÚ
trunc_normal_é c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú
LocalModelc s t t| ƒ ¡ || _|| _d S ©N)Úsuperr Ú__init__ÚbaseÚ predictor)Úselfr r ©Ú __class__© õa D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\trainmodel\models.pyr s zLocalModel.__init__c C s | |¡}| |¡}|S r )r r ©r ÚxÚoutr r r Úforward s
zLocalModel.forward©Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú
LocalModel_ptc s t t| ƒ ¡ || _|| _d S r )r
r r Ú generatorr )r r r r r r r # s zLocalModel_pt.__init__c C s | |¡}| |¡}|S r )r r r r r r r ) s
zLocalModel_pt.forwardr r r r r r " s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚLocalModel_repptc s$ t t| ƒ ¡ || _|| _|| _d S r )r
r! r r r r )r r r r r r r r 0 s zLocalModel_reppt.__init__c C s" | |¡}| |¡}| |¡}|S r )r r r r r r r r 7 s
zLocalModel_reppt.forwardr r r r r r! / s r! c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú FedAvgCNNé é
é c
s� t ƒ ¡ t tj|dddddd�tjdd�tjdd �¡| _t tjdd
ddddd�tjdd�tjdd �¡| _t t |d ¡tjdd�¡| _
t d |¡| _ d S ) Né é r r# T)Ú kernel_sizeÚpaddingÚstrideÚbias©Úinplace)é r. ©r( é@ i ) r
r ÚnnÚ
SequentialÚConv2dÚReLUÚ MaxPool2dÚconv1Úconv2ÚLinearÚfc1Úfc)r Ú in_featuresÚ num_classesÚdimr r r r ` s8
û
ø
û
ø
şzFedAvgCNN.__init__c C s8 | |¡}| |¡}t |d¡}| |¡}| |¡}|S ©Nr# )r6 r7 ÚtorchÚflattenr9 r: r r r r r | s
zFedAvgCNN.forward)r# r$ r% r r r r r r" _ s r" c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú FedAvgMLPé r$ éÈ c s8 t ƒ ¡ t ||¡| _t ||¡| _tjdd�| _d S )NTr, )r
r r1 r8 r9 Úfc2r4 Úact)r r; r< Ú
hidden_dimr r r r ˆ s
zFedAvgMLP.__init__c C s: |j dkr | | d¡d¡}| | |¡¡}| |¡}|S )Né r éÿÿÿÿ)ÚndimÚviewÚsizerE r9 rD ©r r r r r r � s
zFedAvgMLP.forward)rB r$ rC r r r r r rA ‡ s rA c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚNetc sj t t| ƒ ¡ t dtdd¡| _t tddd¡| _t d¡| _ t d¡| _
t dd¡| _ t dd¡| _
d S ) Nr# r. r& g Ğ?ç à?i H é€ r$ )r
rM r r1 r3 Ú
batch_sizer6 r7 ÚDropoutÚdropout1Údropout2r8 r9 r: )r r r r r ˜ s z Net.__init__c C s� | |¡}t ¡ |ƒ}t dd¡|ƒ}| |¡}| |¡}t ¡ |ƒ}t dd¡|ƒ}| |¡}t |d¡}| |¡}t ¡ |ƒ}|
|¡}t j |dd�}|S )Nr. r# ©r= )
r6 r1 r4 r5 rR r7 rS r? r@ r9 r: ÚFÚ log_softmax©r r Úoutputr r r r ¡ s
z Net.forwardr r r r r rM — s rM c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú
Mclr_LogisticrB r$ c s t t| ƒ ¡ t ||¡| _d S r )r
rY r r1 r8 r: )r Ú input_dimr< r r r r ´ s zMclr_Logistic.__init__c C s( t |d¡}| |¡}tj|dd�}|S ©Nr# rT )r? r@ r: rU rV rW r r r r ¸ s
zMclr_Logistic.forward)rB r$ r r r r r rY ³ s rY c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚDNNrB éd r$ c s. t t| ƒ ¡ t ||¡| _t ||¡| _d S r )r
r\ r r1 r8 r9 r: )r rZ Zmid_dimr< r r r r Á s z DNN.__init__c C s8 t |d¡}t | |¡¡}| |¡}tj|dd�}|S r[ )r? r@ rU Úrelur9 r: rV rL r r r r Æ s
z DNN.forward)rB r] r$ r r r r r r\ À s r\ c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )ÚCifarNetr$ c sr t t| ƒ ¡ t ddd¡| _t dd¡| _t dtd¡| _ t
td d d¡| _ t
dd¡| _ t
d|¡| _
d S )Né é r' r. éx éT )r
r_ r r1 r3 r6 r5 ÚpoolrP r7 r8 r9 rD r: )r r< r r r r Ğ s zCifarNet.__init__c C s| | t | |¡¡¡}| t | |¡¡¡}| dtd d ¡}t | |¡¡}t | |¡¡}| |¡}tj
|dd�}|S )NrH r' r# rT ) rd rU r^ r6 r7 rJ rP r9 rD r: rV rL r r r r Ù s
zCifarNet.forward)r$ r r r r r r_ Ï s r_ c C s | j j}| d¡dks$| d¡dkrBtj | j¡ tj | j¡ nZ| d¡dkrrtj | jdd¡ tj | j¡ n*| d¡dkrœtj
| j¡ tj | j¡ d S )Nr3 rH ÚConvTranspose2dZ BatchNormg ğ?g{®Gáz”?r8 ) r r Úfindr1 ÚinitÚkaiming_uniform_ÚweightÚzeros_r+ Únormal_Úxavier_normal_)ÚmÚ classnamer r r Ú init_weights s ro c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú PadPrompterr# é Nc s´ t t| ƒ ¡ |}|}|| _|| _||d | _t t d| j||g¡¡| _
t t d| j||g¡¡| _ t t d| j||d |g¡¡| _ t t d| j||d |g¡¡| _
d S )Nr. r# )r
rp r ÚargsÚinchanelÚ base_sizer1 Ú Parameterr? ÚzerosÚpad_upÚpad_downÚpad_leftÚ pad_right©r rs Úpad_sizeÚ
image_sizerr r r r r s $zPadPrompter.__init__c C sn t d| j| j| j¡ | jj¡}t j| j|| j gdd�}t j| j
|| j gdd�}t | d¡|g ¡}|| S )Nr# r` rT r. r )
r? rv rs rt Útorr ÚdeviceÚcatry rz rw rx rK )r r r Úpromptr r r r ) s
zPadPrompter.forward)r# r# rq Nr r r r r rp s rp c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚFixedPatchPrompterr# rq Nc sJ t t| ƒ ¡ || _|| _|| _t t d| j| j| jg¡¡| _
|| _ d S r> ) r
r‚ r ÚisizeÚpsizers r1 ru r? ÚrandnÚpatchrr r{ r r r r 4 s zFixedPatchPrompter.__init__c C sP t d| j| j| jg¡ | jj¡}| j|d d …d d …d | j…d | j…f< || S r> ) r? rv rs rƒ r~ rr r r† r„ )r r r� r r r r = s "&zFixedPatchPrompter.forward)r# r# rq Nr r r r r r‚ 3 s r‚ c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚRandomPatchPrompterr# rq Nc sJ t t| ƒ ¡ || _|| _|| _t t d| j| j| jg¡¡| _
|| _ d S r> ) r
r‡ r rƒ r„ rs r1 ru r? r… r† rr r{ r r r r E s z RandomPatchPrompter.__init__c C s€ t j | j| j ¡}t j | j| j ¡}t d| j| j| jg¡ | j j
¡}| j |d d …d d …||| j …||| j …f< || S r> ) ÚnpÚrandomÚchoicerƒ r„ r? rv rs r~ rr r r† )r r Úx_Zy_r� r r r r N s
".zRandomPatchPrompter.forward)r# r# rq Nr r r r r r‡ D s r‡ c s& e Zd Zd ‡ fdd„ Zdd„ Z‡ ZS )
ÚLeNeté é r$ Nc
sÌ t t| ƒ ¡ t tjdddd�t d¡t ¡ tjdddd�tjdd�t d¡t ¡ ¡| _ tj
|d d
�| _ tj dd�| _
t ||¡| _| j t¡ t ||¡| _|d kr¼tjj| jd d
�| _| j t¡ d S )Nr# é r' r/ r. é2 rN ©ÚpT)ÚaffineÚwnri )Úname)r
rŒ r r1 r2 r3 r5 r4 Ú Dropout2dÚ conv_paramsÚ BatchNorm1dÚbnrQ Údropoutr8 Ú
bottleneckÚapplyro r: ÚutilsÚ weight_norm)r Ú feature_dimZbottleneck_dimr< Ziswnr r r r X s$
ù zLeNet.__init__c C sV | |¡}| | d¡d¡}| |¡}| |¡}| |¡}| |¡}tj|dd�}|S ©Nr rH r# rT ) r— rJ rK r› r™ rš r: rU rV rL r r r r m s
z
LeNet.forward)r� r� r$ Nr r r r r rŒ W s rŒ c s& e Zd Zd ‡ fdd„ Zd d
„ Z‡ ZS ) ÚLSTMNetr. Fçš™™™™™É?r éK� r$ c s` t ƒ ¡ t |¡| _t |||¡| _tj|||||dd�| _|rJ|d n|}t ||¡| _
d S )NT)Ú
input_sizeÚ hidden_sizeÚ
num_layersÚ
bidirectionalrš Ú batch_firstr. ) r
r r1 rQ rš Ú EmbeddingÚ embeddingÚLSTMÚlstmr8 r: ) r rF r¦ r§ rš Ú padding_idxÚ
vocab_sizer< Údimsr r r r — s
ûzLSTMNet.__init__c C s’ |\}}| |¡}tjjj||ddd�}| |¡\}\}}tjjj|dd�\} }
t | d d …dd d …f ¡} | | ¡} |
| ¡} t j | dd�} | S )NTF)r¨ Úenforce_sorted)r¨ rH r# rT )
rª r1 r� ÚrnnÚpack_padded_sequencer¬ Úpad_packed_sequencer? Úrelu_rš r: rU rV ) r r ÚtextÚ text_lengthsZembeddedZpacked_embeddedZ
packed_outputÚhiddenÚcellr Z out_lengthsr r r r ¦ s
zLSTMNet.forward)r. Fr¢ r r£ r$ r r r r r r¡ – s ÿr¡ c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚfastTextr r£ r$ c s> t t| ƒ ¡ t |||¡| _t ||¡| _t ||¡| _d S r ) r
r¹ r r1 r© rª r8 r9 r: )r rF r r® r< r r r r ¼ s zfastText.__init__c C s> |\}}| |¡}| | d¡¡}| |¡}tj|dd�}|S r[ )rª r9 Úmeanr: rU rV )r r rµ r¶ Ú
embedded_sentÚhÚzr r r r r È s
zfastText.forward)r r£ r$ r r r r r r¹ » s r¹ c s: e Zd Zddddgddddd f‡ fd
d „ Zd d
„ Z‡ ZS )ÚTextCNNr] r` rG r' rC gš™™™™™é?r r£ r$ c sæ t t| ƒ ¡ t |||¡| _t tj|||d d�t ¡ t ||d d ¡¡| _
t tj|||d d�t ¡ t ||d d ¡¡| _ t tj|||d d�t ¡ t ||d d ¡¡| _ t
|¡| _t |t|ƒ |¡| _d S )Nr )Ú in_channelsÚ out_channelsr( r# r. )r
r¾ r r1 r© rª r2 ÚConv1dr4 Ú MaxPool1dr6 r7 Úconv3rQ rš r8 Úlenr: ) r rF Ú num_channelsr( Úmax_lenrš r r® r< r r r r Õ s& ııı zTextCNN.__init__c C s„ |\}}| |¡ ddd¡}| |¡ d¡}| |¡ d¡}| |¡ d¡}t |||fd¡}| |¡} | | ¡}
t
j |
dd�}
|
S )Nr r. r# rT ) rª Úpermuter6 Úsqueezer7 rà r? r€ rš r: rU rV ) r r rµ r¶ r» Z conv_out1Z conv_out2Z conv_out3Zall_outZfinal_feature_mapr r r r r ó s
zTextCNN.forwardr r r r r r¾ Ô s ÿ r¾ c s* e Zd ZdZd
‡ fdd„ Zdd „ Z‡ ZS ) Ú
PatchEmbedz{
Image to Patch Embedding
CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
éà r
r` é c sd t ƒ ¡ t|ƒ}t|ƒ}|d |d |d |d }|| _|| _|| _tj||||d�| _d S )Nr# r )r( r* ) r
r r Úimg_sizeÚ
patch_sizeÚ num_patchesr1 r3 Úproj)r rÌ rÍ Úin_chansÚ embed_dimrÎ r r r r
s
zPatchEmbed.__init__c
C st |j \}}}}|| jd kr*|| jd ksXtd|› d|› d| jd › d| jd › d� ƒ‚| |¡ d¡ dd¡}|S )Nr r# zInput image size (Ú*z) doesn't match model (z).r. )ÚshaperÌ ÚAssertionErrorrÏ r@ Ú transpose)r r ÚBÚCÚHÚWr r r r s (ÿzPatchEmbed.forward)rÊ r
r` rË ©r r r Ú__doc__r r r r r r r rÉ s rÉ c s4 e Zd ZdZddejdf‡ fdd„ Zdd„ Z‡ ZS )ÚFFNz�
FFN (from timm)
:param in_features:
:param hidden_features:
:param out_features:
:param act_layer:
:param drop:
Nç c sN t ƒ ¡ |p|}|p|}t ||¡| _|ƒ | _t ||¡| _t |¡| _d S r ) r
r r1 r8 r9 rE rD rQ Údrop)r r; Úhidden_featuresÚ out_featuresÚ act_layerrŞ r r r r , s
z FFN.__init__c C s6 | |¡}| |¡}| |¡}| |¡}| |¡}|S r )r9 rE rŞ rD rL r r r r 8 s
z FFN.forward) r r r rÛ r1 ÚGELUr r r r r r r rÜ " s rÜ c s* e Zd ZdZd
‡ fdd„ Zdd „ Z‡ ZS ) Ú Attentiona�
qkv Transform + MSA(MHSA) (from timm)
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim=CNN feature dim, because the patch size is 1x1
:param num_heads:
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param attn_drop: dropout rate after MHSA
:param proj_drop:
é FNrİ c sf t ƒ ¡ || _|| }|p"|d | _tj||d |d�| _t |¡| _t ||¡| _ t |¡| _
d S )Ng à¿r` )r+ ) r
r Ú num_headsÚscaler1 r8 ÚqkvrQ Ú attn_droprÏ Ú proj_drop)r r= rå Úqkv_biasÚqk_scalerè ré Úhead_dimr r r r Q s
zAttention.__init__c
C s´ |j \}}}| |¡ ||d| j|| j ¡ ddddd¡}|d |d |d }}}|| dd¡ | j } | jdd�} | | ¡} | | dd¡ |||¡}| |¡}|
|¡}|S ) Nr` r. r r# rG éşÿÿÿrH rT ) rÓ rç Úreshaperå rÇ rÕ ræ Úsoftmaxrè rÏ ré )
r r ÚbatchZ patch_numberZ patch_dimrç ÚqÚkÚvÚattnr r r r ^ s$ ÿ ÿ
zAttention.forward)rä FNrİ rİ rÚ r r r r rã D s
rã c s: e Zd Zddddddejejf‡ fdd„ Zdd„ Z‡ ZS ) ÚBlockg @FNrİ c sp t ƒ ¡ |
|ƒ| _t||||||d�| _|dkr:t|ƒnt ¡ | _|
|ƒ| _ t
|| ƒ} t || | |d�| _ dS )aê
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim
:param num_heads:
:param mlp_ratio: FFN
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param drop:
:param attn_drop: dropout rate after Attention
:param drop_path: dropout rate after sd
:param act_layer: FFN act
:param norm_layer: Pre Norm
)rå rê rë rè ré rİ )r; rß rá rŞ N)
r
r Únorm1rã rô r r1 ÚIdentityÚ drop_pathÚnorm2ÚintrÜ Úmlp) r r= rå Ú mlp_ratiorê rë rŞ rè rø rá Ú
norm_layerZmlp_hidden_dimr r r r { s
ÿ
zBlock.__init__c C s8 || | | |¡¡¡ }|| | | |¡¡¡ }|S r )rø rô rö rû rù rL r r r r š s z
Block.forward) r r r r1 râ Ú LayerNormr r r r r r r rõ y s
ÿ rõ c sR e Zd ZdZddddddddd d
d d d ed
d
f‡ fd d
„ Zdd„ Zdd„ Z‡ ZS )ÚVisionTransformerz¬
Vision Transformer
A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
- https://arxiv.org/abs/2010.11929
r& rG r` r$ rO rä g @TNrİ c
sX t ƒ ¡ || _ˆ | _| _d| _ˆp2ttjdd�‰ˆ p<tj ‰ ||||ˆd�| _
| j
j }t t
ddˆ¡¡| _t t
d|| j ˆ¡¡| _tjˆd�| _dd„ t
d|
|¡D ƒ‰tj‡ ‡‡‡‡‡‡‡‡f d d„t|ƒD ƒ� | _ˆˆƒ| _|
�r |
| _t td
t ˆ|
¡fd t ¡ fgƒ¡| _n
t ¡ | _| jdk�rDt | j| j¡nt ¡ | _ d | _ d S )
aš
Args:
img_size (int, tuple): input image size
patch_size (int, tuple): patch size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (int): embedding dimension
depth (int): depth of transformer
num_heads (int): number of attention heads
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
embed_layer (nn.Module): patch embedding layer
norm_layer: (nn.Module): normalization layer
r# g�íµ ÷Æ°>)Úeps)rÌ rÍ rĞ rÑ r‘ c S s g | ] }| ¡ ‘qS r )Úitem)Ú.0r r r r Ú
<listcomp>Ò s z.VisionTransformer.__init__.<locals>.<listcomp>r c
s* g | ]"}t ˆˆˆˆˆˆˆ| ˆˆ d � ‘qS )) r= rå rü rê rŞ rè rø rı rá )rõ )r Úi© rá Úattn_drop_rateZdprÚ drop_raterÑ rü rı rå rê r r r Õ s ş ÿr: rE N) r
r r< Ú num_featuresrÑ Z
num_tokensr r1 rş râ Ú patch_embedrÎ ru r? rv Ú cls_tokenÚ pos_embedrQ Úpos_dropÚlinspacer2 ÚrangeÚblocksÚnormr r8 ÚTanhÚ
pre_logitsr÷ r: Z head_dist)r rÌ rÍ rĞ r< rÑ Údepthrå rü rê Úrepresentation_sizer r Zdrop_path_rateZ embed_layerrı rá rÎ r r r r ª s<
ÿ ı
ş
&zVisionTransformer.__init__c C sZ | |¡}| j |jd dd¡}tj||fdd�}| || j ¡}| |¡}| |¡}|S r )
r r
ÚexpandrÓ r? r€ r r r r )r r r
r r r Úforward_featuresë s
z"VisionTransformer.forward_featuresc C s. | |¡}| |d d …df ¡}| |¡}|S )Nr )r r r: rL r r r r ö s
zVisionTransformer.forward) r r r rÛ rÉ r r r r r r r r rÿ £ s şA rÿ ).r? Útorch.nnr1 Útorch.nn.functionalÚ
functionalrU ÚmathÚloggingÚ functoolsr Ú collectionsr Únumpyrˆ Z timm.datar r Ztimm.models.layersr r r r rP ÚModuler r r! r" rA rM rY r\ r_ ro rp r‚ r‡ rŒ r¡ r¹ r¾ rÉ rÜ rã rõ rÿ r r r r Ú<module> s@
0(
@
?%0 "5* | 21,084 | Python | .py | 210 | 97.457143 | 663 | 0.359138 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,742 | mobilenet_v2.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/mobilenet_v2.cpython-37.pyc | B
Ê:cc ã @ sv d dl mZ d dlmZ ddgZddiZddd„ZG d d
„ d
ejƒZG d d „ d ej ƒZ
G d
d„ dej ƒZ ddd„Z dS )é )Únn)Úload_state_dict_from_urlÚ MobileNetV2Ú mobilenet_v2z=https://download.pytorch.org/models/mobilenet_v2-b0353104.pthNc C sB |dkr |}t |t| |d ƒ| | ƒ}|d| k r>||7 }|S )aD
This function is taken from the original tf repo.
It ensures that all layers have a channel number that is divisible by 8
It can be seen here:
https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
:param v:
:param divisor:
:param min_value:
:return:
Né gÍÌÌÌÌÌì?)ÚmaxÚint)ÚvÚdivisorÚ min_valueÚnew_v© r
úL/root/autodl-tmp/PFL-Non-IID-master/system/flcore/trainmodel/mobilenet_v2.pyÚ_make_divisible
s r c s e Zd Zd‡ fdd„ Z‡ ZS )Ú
ConvBNReLUé é Nc sR |d d }|d krt j}tt| ƒ t j||||||dd�||ƒt jdd�¡ d S )Nr r F)ÚgroupsÚbiasT)Úinplace)r Ú BatchNorm2dÚsuperr Ú__init__ÚConv2dÚReLU6)ÚselfÚ in_planesÚ
out_planesÚ kernel_sizeÚstrider Ú
norm_layerÚpadding)Ú __class__r
r r " s
zConvBNReLU.__init__)r r r N)Ú__name__Ú
__module__Ú __qualname__r Ú
__classcell__r
r
)r" r r ! s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )ÚInvertedResidualNc s¸ t t| ƒ ¡ || _|dks t‚|d kr.tj}tt|| ƒƒ}| jdkoN||k| _ g }|dkrt|
t ||d|d�¡ | t |||||d�tj
||ddddd�||ƒg¡ tj|� | _d S )N)r r r )r r )r r r r F)r )r r' r r ÚAssertionErrorr r r ÚroundÚuse_res_connectÚappendr Úextendr Ú
SequentialÚconv)r ÚinpÚoupr Ú expand_ratior Ú
hidden_dimÚlayers)r" r
r r . s zInvertedResidual.__init__c C s" | j r|| |¡ S | |¡S d S )N)r* r. )r Úxr
r
r ÚforwardF s zInvertedResidual.forward)N)r# r$ r% r r5 r& r
r
)r" r r' - s r' c s. e Zd Zd ‡ fdd„ Zdd„ Zd d
„ Z‡ ZS ) r éè ç ğ?Né c s< t t| ƒ ¡ |dkrt}|dkr(tj}d}d}|dkr‚ddddgddddgddd dgdd
d dgdd d dgdd
d dgddddgg}t|ƒdks�t|d ƒd kr¬td |¡ƒ‚t || |ƒ}t |t
d|ƒ |ƒ| _ t d |d|d�g} xd|D ]\\}
} } }
t | | |ƒ}x@t
| ƒD ]4}|dk�r |
nd}| |||||
|d�¡ |}�q W qèW | t || j d|d�¡ tj| � | _t d¡| _t | j |¡| _x®| ¡ D ]¢}t|tjƒ�rÒtjj|jdd� |jdk �r2tj |j¡ n`t|tjtj fƒ�rtj |j¡ tj |j¡ n.t|tjƒ�r’tj |jdd¡ tj |j¡ �q’W dS )aA
MobileNet V2 main class
Args:
num_classes (int): Number of classes
width_mult (float): Width multiplier - adjusts number of channels in each layer by this amount
inverted_residual_setting: Network structure
round_nearest (int): Round the number of channels in each layer to be a multiple of this number
Set to 1 to turn off rounding
block: Module specifying inverted residual building block for mobilenet
norm_layer: Module specifying the normalization layer to use
Né i r é é é r r é@ é é` é i@ r zIinverted_residual_setting should be non-empty or a 4-element list, got {}g ğ?)r r )r1 r )r r gš™™™™™É?Úfan_out)Úmodeg{®Gáz„?) r r r r' r r ÚlenÚ
ValueErrorÚformatr r Ú last_channelr Úranger+ r- ÚfeaturesÚDropoutÚdropoutÚLinearÚfcÚmodulesÚ
isinstancer ÚinitÚkaiming_normal_Úweightr Úzeros_Ú GroupNormÚones_Únormal_)r Ú num_classesÚ
width_multÚinverted_residual_settingÚ
round_nearestÚblockr Ú
input_channelrF rH ÚtÚcÚnÚsÚoutput_channelÚir Úm)r" r
r r N sT
zMobileNetV2.__init__c C s> | |¡}tj |d¡ |jd d¡}| |¡}| |¡}|S )Nr r éÿÿÿÿ)rH r Ú
functionalÚadaptive_avg_pool2dÚreshapeÚshaperJ rL )r r4 r
r
r Ú
_forward_implŸ s
zMobileNetV2._forward_implc C s
| |¡S )N)rh )r r4 r
r
r r5 © s zMobileNetV2.forward)r6 r7 Nr8 NN)r# r$ r% r rh r5 r& r
r
)r" r r M s K
FTc K sh t f |�}| rdttd |d�}i }x6| ¡ D ]*\}}d|krF|||< q,||| dd¡< q,W | |¡ |S )aC
Constructs a MobileNetV2 architecture from
`"MobileNetV2: Inverted Residuals and Linear Bottlenecks" <https://arxiv.org/abs/1801.04381>`_.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
r )ÚprogressÚ
classifierz classifier.1rL )r r Ú
model_urlsÚitemsÚreplaceÚload_state_dict)Ú
pretrainedri ÚkwargsÚmodelÚ
state_dictÚnew_dictÚkr r
r
r r s
)N)FT)
Útorchr Z torch.hubr Ú__all__rk r r- r ÚModuler' r r r
r
r
r Ú<module> s
` | 5,660 | Python | .py | 67 | 80.761194 | 395 | 0.473618 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,743 | alexnet.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/alexnet.cpython-38.pyc | U
”jfc) ã @ sP d dl Z d dlmZ d dlmZ ddgZddiZG dd„ dejƒZd
d d„Z dS ) é N)Úload_state_dict_from_urlÚAlexNetÚalexnetz<https://download.pytorch.org/models/alexnet-owt-4df8aa71.pthc s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )r éè c s t t| ƒ ¡ t tjdddddd�tjdd�tjddd �tjdd
d dd �tjdd�tjddd �tjd
d
ddd �tjdd�tjd
dddd �tjdd�tjddddd �tjdd�tjddd �¡
| _t d¡| _
t t ¡ t dd¡tjdd�t ¡ t dd¡tjdd�¡| _
t d|¡| _d S )Né é@ é é é )Ú kernel_sizeÚstrideÚpaddingT)Úinplace)r r éÀ é )r r
i€ é é )é r i $ i )Úsuperr Ú__init__ÚnnÚ
SequentialÚConv2dÚReLUÚ MaxPool2dÚfeaturesÚAdaptiveAvgPool2dÚavgpoolÚDropoutÚLinearÚ
classifierÚfc)ÚselfÚ num_classes©Ú __class__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\trainmodel\alexnet.pyr s4
ó
úzAlexNet.__init__c C s8 | |¡}| |¡}t |d¡}| |¡}| |¡}|S )Nr )r r ÚtorchÚflattenr r! )r" Úxr& r& r' Úforward+ s
zAlexNet.forward)r )Ú__name__Ú
__module__Ú __qualname__r r+ Ú
__classcell__r& r& r$ r' r
s FTc K sd t f |�}| r`ttd |d�}i }| ¡ D ]*\}}d|krD|||< q*||| dd¡< q*| |¡ |S )a AlexNet model architecture from the
`"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
r )Úprogressz classifier.6r! )r r Ú
model_urlsÚitemsÚreplaceÚload_state_dict)Ú
pretrainedr0 ÚkwargsÚmodelÚ
state_dictÚnew_dictÚkÚvr& r& r' r 4 s
ÿ
)FT)
r( Útorch.nnr Z torch.hubr Ú__all__r1 ÚModuler r r& r& r& r' Ú<module> s ÿ' | 2,184 | Python | .py | 34 | 62.352941 | 303 | 0.465581 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,744 | models.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/models.cpython-37.pyc | B
éecTg ã @ sä d dl Z d dlmZ d dlm mZ d dlZd dlZd dlm Z d dl
m Z d dl Z
d dlmZmZ d dlmZmZmZmZ dZG dd„ dejƒZG d d
„ d
ejƒZG d d „ d ejƒZG d
d„ dejƒZG dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ dd„ Z!G dd „ d ejƒZ"G d d „ d ejƒZ#G d d „ d ejƒZ$G d!d"„ d"ejƒZ%G d#d$„ d$ejƒZ&G d%d&„ d&ejƒZ'G d'd(„ d(ejƒZ(G d)d*„ d*ejƒZ)G d+d,„ d,ejƒZ*G d-d.„ d.ejƒZ+dS )/é N)Úpartial)Ú OrderedDict)ÚIMAGENET_DEFAULT_MEANÚIMAGENET_DEFAULT_STD)Ú
StdConv2dSameÚDropPathÚ to_2tupleÚ
trunc_normal_é c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú
LocalModelc s t t| ƒ ¡ || _|| _d S )N)Úsuperr Ú__init__ÚbaseÚ predictor)Úselfr r )Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/trainmodel/models.pyr
s zLocalModel.__init__c C s | |¡}| |¡}|S )N)r r )r ÚxÚoutr r r Úforward s
zLocalModel.forward)Ú__name__Ú
__module__Ú __qualname__r
r Ú
__classcell__r r )r r r s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú
LocalModel_ptc s t t| ƒ ¡ || _|| _d S )N)r r r
Ú generatorr )r r r )r r r r
# s zLocalModel_pt.__init__c C s | |¡}| |¡}|S )N)r r )r r r r r r r ) s
zLocalModel_pt.forward)r r r r
r r r r )r r r " s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚLocalModel_repptc s$ t t| ƒ ¡ || _|| _|| _d S )N)r r r
r r r )r r r r )r r r r
0 s zLocalModel_reppt.__init__c C s" | |¡}| |¡}| |¡}|S )N)r r r )r r r r r r r 7 s
zLocalModel_reppt.forward)r r r r
r r r r )r r r / s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú FedAvgCNNé é
é c
s� t ƒ ¡ t tj|dddddd�tjdd�tjdd �¡| _t tjdd
ddddd�tjdd�tjdd �¡| _t t |d ¡tjdd�¡| _
t d |¡| _ d S ) Né é r r T)Ú kernel_sizeÚpaddingÚstrideÚbias)Úinplace)é r) )r$ é@ i ) r r
ÚnnÚ
SequentialÚConv2dÚReLUÚ MaxPool2dÚconv1Úconv2ÚLinearÚfc1Úfc)r Ú in_featuresÚ num_classesÚdim)r r r r
` s.
zFedAvgCNN.__init__c C s8 | |¡}| |¡}t |d¡}| |¡}| |¡}|S )Nr )r0 r1 ÚtorchÚflattenr3 r4 )r r r r r r r | s
zFedAvgCNN.forward)r r r! )r r r r
r r r r )r r r _ s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú FedAvgMLPé r éÈ c s8 t ƒ ¡ t ||¡| _t ||¡| _tjdd�| _d S )NT)r( )r r
r+ r2 r3 Úfc2r. Úact)r r5 r6 Ú
hidden_dim)r r r r
ˆ s
zFedAvgMLP.__init__c C s: |j dkr | | d¡d¡}| | |¡¡}| |¡}|S )Né r éÿÿÿÿ)ÚndimÚviewÚsizer> r3 r= )r r r r r r � s
zFedAvgMLP.forward)r; r r< )r r r r
r r r r )r r r: ‡ s r: c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚNetc sj t t| ƒ ¡ t dtdd¡| _t tddd¡| _t d¡| _ t d¡| _
t dd¡| _ t dd¡| _
d S ) Nr r) r" g Ğ?g à?i H é€ r )r rE r
r+ r- Ú
batch_sizer0 r1 ÚDropoutÚdropout1Údropout2r2 r3 r4 )r )r r r r
˜ s z Net.__init__c C s� | |¡}t ¡ |ƒ}t dd¡|ƒ}| |¡}| |¡}t ¡ |ƒ}t dd¡|ƒ}| |¡}t |d¡}| |¡}t ¡ |ƒ}|
|¡}t j |dd�}|S )Nr) r )r7 )
r0 r+ r. r/ rI r1 rJ r8 r9 r3 r4 ÚFÚ log_softmax)r r Úoutputr r r r ¡ s
z Net.forward)r r r r
r r r r )r r rE — s rE c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú
Mclr_Logisticé r c s t t| ƒ ¡ t ||¡| _d S )N)r rN r
r+ r2 r4 )r Ú input_dimr6 )r r r r
´ s zMclr_Logistic.__init__c C s( t |d¡}| |¡}tj|dd�}|S )Nr )r7 )r8 r9 r4 rK rL )r r rM r r r r ¸ s
zMclr_Logistic.forward)rO r )r r r r
r r r r )r r rN ³ s rN c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚDNNé éd r c s. t t| ƒ ¡ t ||¡| _t ||¡| _d S )N)r rQ r
r+ r2 r3 r4 )r rP Zmid_dimr6 )r r r r
Á s z DNN.__init__c C s8 t |d¡}t | |¡¡}| |¡}tj|dd�}|S )Nr )r7 )r8 r9 rK Úrelur3 r4 rL )r r r r r r Æ s
z DNN.forward)rR rS r )r r r r
r r r r )r r rQ À s rQ c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )ÚCifarNetr c sr t t| ƒ ¡ t ddd¡| _t dd¡| _t dtd¡| _ t
td d d¡| _ t
dd¡| _ t
d|¡| _
d S )Né é r# r) éx éT )r rU r
r+ r- r0 r/ ÚpoolrG r1 r2 r3 r= r4 )r r6 )r r r r
Ğ s zCifarNet.__init__c C s| | t | |¡¡¡}| t | |¡¡¡}| dtd d ¡}t | |¡¡}t | |¡¡}| |¡}tj
|dd�}|S )NrA r# r )r7 ) rZ rK rT r0 r1 rC rG r3 r= r4 rL )r r r r r r Ù s
zCifarNet.forward)r )r r r r
r r r r )r r rU Ï s rU c C s | j j}| d¡dks$| d¡dkrBtj | j¡ tj | j¡ nZ| d¡dkrrtj | jdd¡ tj | j¡ n*| d¡dkrœtj
| j¡ tj | j¡ d S )Nr- rA ÚConvTranspose2dZ BatchNormg ğ?g{®Gáz”?r2 ) r r Úfindr+ ÚinitÚkaiming_uniform_ÚweightÚzeros_r' Únormal_Úxavier_normal_)ÚmÚ classnamer r r Ú init_weights s re c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú PadPrompterr é Nc s´ t t| ƒ ¡ |}|}|| _|| _||d | _t t d| j||g¡¡| _
t t d| j||g¡¡| _ t t d| j||d |g¡¡| _ t t d| j||d |g¡¡| _
d S )Nr) r )r rf r
ÚargsÚinchanelÚ base_sizer+ Ú Parameterr8 ÚrandnÚpad_upÚpad_downÚpad_leftÚ pad_right)r ri Úpad_sizeÚ
image_sizerh )r r r r
s $zPadPrompter.__init__c C sn t d| j| j| j¡ | jj¡}t j| j|| j gdd�}t j| j
|| j gdd�}t | d¡|g ¡}|| S )Nr rV )r7 r) r )
r8 Úzerosri rj Útorh ÚdeviceÚcatro rp rm rn rD )r r r Úpromptr r r r ) s
zPadPrompter.forward)r r rg N)r r r r
r r r r )r r rf s rf c s& e Zd Zd ‡ fdd„ Zdd„ Z‡ ZS )
ÚLeNeté é r Nc
sÌ t t| ƒ ¡ t tjdddd�t d¡t ¡ tjdddd�tjdd�t d¡t ¡ ¡| _ tj
|d d
�| _ tj dd�| _
t ||¡| _| j t¡ t ||¡| _|d kr¼tjj| jd d
�| _| j t¡ d S )Nr é r# )r$ r) é2 g à?)ÚpT)ÚaffineÚwnr_ )Úname)r rx r
r+ r, r- r/ r. Ú Dropout2dÚ conv_paramsÚ BatchNorm1dÚbnrH Údropoutr2 Ú
bottleneckÚapplyre r4 ÚutilsÚ weight_norm)r Ú feature_dimZbottleneck_dimr6 Ziswn)r r r r
4 s"
zLeNet.__init__c C sV | |¡}| | d¡d¡}| |¡}| |¡}| |¡}| |¡}tj|dd�}|S )Nr rA r )r7 ) r‚ rC rD r† r„ r… r4 rK rL )r r r r r r I s
z
LeNet.forward)ry rz r N)r r r r
r r r r )r r rx 3 s rx c s& e Zd Zd ‡ fdd„ Zd d
„ Z‡ ZS ) ÚLSTMNetr) Fçš™™™™™É?r éK� r c s` t ƒ ¡ t |¡| _t |||¡| _tj|||||dd�| _|rJ|d n|}t ||¡| _
d S )NT)Ú
input_sizeÚ hidden_sizeÚ
num_layersÚ
bidirectionalr… Ú batch_firstr) ) r r
r+ rH r… Ú EmbeddingÚ embeddingÚLSTMÚlstmr2 r4 ) r r? r� r‘ r… Ú padding_idxÚ
vocab_sizer6 Údims)r r r r
s s
zLSTMNet.__init__c C s’ |\}}| |¡}tjjj||ddd�}| |¡\}\}}tjjj|dd�\} }
t | d d …dd d …f ¡} | | ¡} |
| ¡} t j | dd�} | S )NTF)r’ Úenforce_sorted)r’ rA r )r7 )
r” r+ rˆ ÚrnnÚpack_padded_sequencer– Úpad_packed_sequencer8 Úrelu_r… r4 rK rL ) r r ÚtextÚ text_lengthsZembeddedZpacked_embeddedZ
packed_outputÚhiddenÚcellr Z out_lengthsr r r r ‚ s
zLSTMNet.forward)r) FrŒ r r� r )r r r r
r r r r )r r r‹ r s r‹ c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚfastTextr éK� r c s> t t| ƒ ¡ t |||¡| _t ||¡| _t ||¡| _d S )N) r r£ r
r+ r“ r” r2 r3 r4 )r r? r— r˜ r6 )r r r r
˜ s zfastText.__init__c C s> |\}}| |¡}| | d¡¡}| |¡}tj|dd�}|S )Nr )r7 )r” r3 Úmeanr4 rK rL )r r rŸ r Ú
embedded_sentÚhÚzr r r r r ¤ s
zfastText.forward)r r¤ r )r r r r
r r r r )r r r£ — s r£ c s: e Zd Zddddgddddd f‡ fd
d „ Zd d
„ Z‡ ZS )ÚTextCNNrS rV r@ r# r< gš™™™™™é?r iK� r c sæ t t| ƒ ¡ t |||¡| _t tj|||d d�t ¡ t ||d d ¡¡| _
t tj|||d d�t ¡ t ||d d ¡¡| _ t tj|||d d�t ¡ t ||d d ¡¡| _ t
|¡| _t |t|ƒ |¡| _d S )Nr )Ú in_channelsÚ out_channelsr$ r r) )r r© r
r+ r“ r” r, ÚConv1dr. Ú MaxPool1dr0 r1 Úconv3rH r… r2 Úlenr4 ) r r? Ú num_channelsr$ Úmax_lenr… r— r˜ r6 )r r r r
± s zTextCNN.__init__c C s„ |\}}| |¡ ddd¡}| |¡ d¡}| |¡ d¡}| |¡ d¡}t |||fd¡}| |¡} | | ¡}
t
j |
dd�}
|
S )Nr r) r )r7 ) r” Úpermuter0 Úsqueezer1 r® r8 rv r… r4 rK rL ) r r rŸ r r¦ Z conv_out1Z conv_out2Z conv_out3Úall_outZfinal_feature_mapr r r r r Ï s
zTextCNN.forward)r r r r
r r r r )r r r© ° s r© c s* e Zd ZdZd
‡ fdd„ Zdd „ Z‡ ZS ) Ú
PatchEmbedz{
Image to Patch Embedding
CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
éà r
rV é c sd t ƒ ¡ t|ƒ}t|ƒ}|d |d |d |d }|| _|| _|| _tj||||d�| _d S )Nr r )r$ r& ) r r
r Úimg_sizeÚ
patch_sizeÚ num_patchesr+ r- Úproj)r r¸ r¹ Úin_chansÚ embed_dimrº )r r r r
æ s
zPatchEmbed.__init__c
C st |j \}}}}|| jd kr*|| jd ksXtd|› d|› d| jd › d| jd › d� ƒ‚| |¡ d¡ dd¡}|S )Nr r zInput image size (Ú*z) doesn't match model (z).r) )Úshaper¸ ÚAssertionErrorr» r9 Ú transpose)r r ÚBÚCÚHÚWr r r r ñ s
,zPatchEmbed.forward)r¶ r
rV r· )r r r Ú__doc__r
r r r r )r r rµ à s rµ c s4 e Zd ZdZddejdf‡ fdd„ Zdd„ Z‡ ZS )ÚFFNz�
FFN (from timm)
:param in_features:
:param hidden_features:
:param out_features:
:param act_layer:
:param drop:
Ng c sN t ƒ ¡ |p|}|p|}t ||¡| _|ƒ | _t ||¡| _t |¡| _d S )N) r r
r+ r2 r3 r> r= rH Údrop)r r5 Úhidden_featuresÚ out_featuresÚ act_layerrÈ )r r r r
s
z FFN.__init__c C s6 | |¡}| |¡}| |¡}| |¡}| |¡}|S )N)r3 r> rÈ r= )r r r r r r s
z FFN.forward) r r r rÆ r+ ÚGELUr
r r r r )r r rÇ ş s rÇ c s* e Zd ZdZd
‡ fdd„ Zdd „ Z‡ ZS ) Ú Attentiona�
qkv Transform + MSA(MHSA) (from timm)
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim=CNN feature dim, because the patch size is 1x1
:param num_heads:
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param attn_drop: dropout rate after MHSA
:param proj_drop:
é FNç c sf t ƒ ¡ || _|| }|p"|d | _tj||d |d�| _t |¡| _t ||¡| _ t |¡| _
d S )Ng à¿rV )r' ) r r
Ú num_headsÚscaler+ r2 ÚqkvrH Ú attn_dropr» Ú proj_drop)r r7 rĞ Úqkv_biasÚqk_scalerÓ rÔ Úhead_dim)r r r r
- s
zAttention.__init__c
C s´ |j \}}}| |¡ ||d| j|| j ¡ ddddd¡}|d |d |d }}}|| dd¡ | j } | jdd�} | | ¡} | | dd¡ |||¡}| |¡}|
|¡}|S ) NrV r) r r r@ éşÿÿÿrA )r7 ) r¿ rÒ ÚreshaperĞ r² rÁ rÑ ÚsoftmaxrÓ r» rÔ )
r r ÚbatchZ patch_numberZ patch_dimrÒ ÚqÚkÚvÚattnr r r r : s
zAttention.forward)rÎ FNrÏ rÏ )r r r rÆ r
r r r r )r r rÍ s
rÍ c s: e Zd Zddddddejejf‡ fdd„ Zdd„ Z‡ ZS ) ÚBlockg @FNg c sp t ƒ ¡ |
|ƒ| _t||||||d�| _|dkr:t|ƒnt ¡ | _|
|ƒ| _ t
|| ƒ} t || | |d�| _ dS )aê
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim
:param num_heads:
:param mlp_ratio: FFN
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param drop:
:param attn_drop: dropout rate after Attention
:param drop_path: dropout rate after sd
:param act_layer: FFN act
:param norm_layer: Pre Norm
)rĞ rÕ rÖ rÓ rÔ g )r5 rÉ rË rÈ N)
r r
Únorm1rÍ rß r r+ ÚIdentityÚ drop_pathÚnorm2ÚintrÇ Úmlp) r r7 rĞ Ú mlp_ratiorÕ rÖ rÈ rÓ rã rË Ú
norm_layerZmlp_hidden_dim)r r r r
W s
zBlock.__init__c C s8 || | | |¡¡¡ }|| | | |¡¡¡ }|S )N)rã rß rá ræ rä )r r r r r r v s z
Block.forward) r r r r+ rÌ Ú LayerNormr
r r r r )r r rà U s
rà c sR e Zd ZdZddddddddd d
d d d ed
d
f‡ fd d
„ Zdd„ Zdd„ Z‡ ZS )ÚVisionTransformerz¬
Vision Transformer
A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
- https://arxiv.org/abs/2010.11929
r" r
rV r rF rÎ g @TNg c
sX t ƒ ¡ || _ˆ | _| _d| _ˆp2ttjdd�‰ˆ p<tj ‰ ||||ˆd�| _
| j
j }t t
ddˆ¡¡| _t t
d|| j ˆ¡¡| _tjˆd�| _dd„ t
d|
|¡D ƒ‰tj‡ ‡‡‡‡‡‡‡‡f d d„t|ƒD ƒ� | _ˆˆƒ| _|
�r |
| _t td
t ˆ|
¡fd t ¡ fgƒ¡| _n
t ¡ | _| jdk�rDt | j| j¡nt ¡ | _ d | _ d S )
aš
Args:
img_size (int, tuple): input image size
patch_size (int, tuple): patch size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (int): embedding dimension
depth (int): depth of transformer
num_heads (int): number of attention heads
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
embed_layer (nn.Module): patch embedding layer
norm_layer: (nn.Module): normalization layer
r g�íµ ÷Æ°>)Úeps)r¸ r¹ r¼ r½ )r} c S s g | ] }| ¡ ‘qS r )Úitem)Ú.0r r r r ú
<listcomp>® s z.VisionTransformer.__init__.<locals>.<listcomp>r c
s* g | ]"}t ˆˆˆˆˆˆˆ| ˆˆ d � ‘qS )) r7 rĞ rç rÕ rÈ rÓ rã rè rË )rà )rí Úi) rË Úattn_drop_rateÚdprÚ drop_rater½ rç rè rĞ rÕ r r rî ² s r4 r> N) r r
r6 Ú num_featuresr½ Z
num_tokensr r+ ré rÌ Ú patch_embedrº rk r8 rs Ú cls_tokenÚ pos_embedrH Úpos_dropÚlinspacer, ÚrangeÚblocksÚnormr r2 ÚTanhÚ
pre_logitsrâ r4 Z head_dist)r r¸ r¹ r¼ r6 r½ ÚdepthrĞ rç rÕ Úrepresentation_sizerò rğ Zdrop_path_rateZ embed_layerrè rË rº )r ) rË rğ rñ rò r½ rç rè rĞ rÕ r r
† s2
&zVisionTransformer.__init__c C sZ | |¡}| j |jd dd¡}tj||fdd�}| || j ¡}| |¡}| |¡}|S )Nr rA r )r7 )
rô rõ Úexpandr¿ r8 rv r÷ rö rú rû )r r rõ r r r Úforward_featuresÇ s
z"VisionTransformer.forward_featuresc C s. | |¡}| |d d …df ¡}| |¡}|S )Nr )r rı r4 )r r r r r r Ò s
zVisionTransformer.forward) r r r rÆ rµ r
r r r r r )r r rê s ? rê ),r8 Útorch.nnr+ Útorch.nn.functionalÚ
functionalrK ÚmathÚloggingÚ functoolsr Ú collectionsr ÚnumpyÚnpZ timm.datar r Ztimm.models.layersr r r r rG ÚModuler r r r r: rE rN rQ rU re rf rx r‹ r£ r© rµ rÇ rÍ rà rê r r r r Ú<module> s<
0(
@
?%0 "5* | 19,905 | Python | .py | 200 | 96.485 | 658 | 0.361362 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,745 | alexnet.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/alexnet.cpython-37.pyc | B
Ê:cc) ã @ sP d dl Z d dlmZ d dlmZ ddgZddiZG dd„ dejƒZd
d d„Z dS ) é N)Úload_state_dict_from_urlÚAlexNetÚalexnetz<https://download.pytorch.org/models/alexnet-owt-4df8aa71.pthc s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )r éè c s t t| ƒ ¡ t tjdddddd�tjdd�tjddd �tjdd
d dd �tjdd�tjddd �tjd
d
ddd �tjdd�tjd
dddd �tjdd�tjddddd �tjdd�tjddd �¡
| _t d¡| _
t t ¡ t dd¡tjdd�t ¡ t dd¡tjdd�¡| _
t d|¡| _d S )Né é@ é é é )Ú kernel_sizeÚstrideÚpaddingT)Úinplace)r r éÀ é )r r
i€ é é )é r i $ i )Úsuperr Ú__init__ÚnnÚ
SequentialÚConv2dÚReLUÚ MaxPool2dÚfeaturesÚAdaptiveAvgPool2dÚavgpoolÚDropoutÚLinearÚ
classifierÚfc)ÚselfÚ num_classes)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/trainmodel/alexnet.pyr s0
zAlexNet.__init__c C s8 | |¡}| |¡}t |d¡}| |¡}| |¡}|S )Nr )r r ÚtorchÚflattenr r! )r" Úxr% r% r& Úforward+ s
zAlexNet.forward)r )Ú__name__Ú
__module__Ú __qualname__r r* Ú
__classcell__r% r% )r$ r& r
s FTc K sh t f |�}| rdttd |d�}i }x6| ¡ D ]*\}}d|krF|||< q,||| dd¡< q,W | |¡ |S )a AlexNet model architecture from the
`"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
r )Úprogressz classifier.6r! )r r Ú
model_urlsÚitemsÚreplaceÚload_state_dict)Ú
pretrainedr/ ÚkwargsÚmodelÚ
state_dictÚnew_dictÚkÚvr% r% r& r 4 s
)FT)
r' Útorch.nnr Z torch.hubr Ú__all__r0 ÚModuler r r% r% r% r& Ú<module> s ' | 2,152 | Python | .py | 33 | 63.30303 | 295 | 0.470505 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,746 | bilstm.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/bilstm.cpython-38.pyc | U
”jfcÁ ã @ s* d dl Z d dl mZ G dd„ dejƒZdS )é N)Únnc s. e Zd Zd ‡ fdd„ Zdd„ Zdd„ Z‡ ZS )
ÚBiLSTM_TextClassificationFNc sú t t| ƒ ¡ || _|| _|| _|| _|| _|| _|| _ | | _
|| _ |
d k rbt j
t |
¡¡| _nt
| j| j ¡| _t j| jd�| _| j
r´t | jd | jd ¡| _t j| j d�| _t j| j | j| j|dd�| _t j| jd�| _t | jd | j¡| _d S )N)Úpé é T)ÚdropoutÚ
bidirectional)Úsuperr Ú__init__Ú
input_sizeÚ hidden_sizeÚ output_sizeÚ
num_layersÚembedding_dropoutÚ lstm_dropoutÚattention_dropoutÚ attentionÚembedding_lengthr Ú EmbeddingÚfrom_pretrainedÚtorchÚtensorÚword_embeddingsÚDropoutÚembedding_dropout_layerÚLinearÚattention_layerÚattention_dropout_layerÚLSTMÚ
lstm_layerÚlstm_dropout_layerÚ output_layer) Úselfr r r
r r r r r r Zembedding_weights©Ú __class__© õK D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\trainmodel\bilstm.pyr
s, ÿz"BiLSTM_TextClassification.__init__c
C s¨ | d¡}t ||¡ d¡}g }t|ƒD ]N\}}t || d |… d¡} t | d¡||d |…d d …f ¡}
| |
¡ q(t t |d¡|fd¡} | | ¡} |
| ¡} | S )Nr r é ) Ú unsqueezer ÚbmmÚsqueezeÚ enumerateÚsoftmaxÚmatmulÚappendÚcatr r )
r" Z lstm_outputÚstateÚseq_lensÚhiddenZ attn_weightsZ new_hiddensÚiÚseq_lenZsoft_attn_weightsZ
new_hiddenZ
concat_hiddenZ
output_hiddenr% r% r& Úattention_forward" s
$
z+BiLSTM_TextClassification.attention_forwardc sê |\}}t |ƒ}| |¡}| |¡}t | jd || jf¡jdd�}t | jd || jf¡jdd�}| ddd¡}| |||f¡\‰ \}}ˆ ddd¡‰ tj
‡ fdd„t |ƒD ƒdd�} | | ¡} | j
rØ| ˆ | |¡‰ n| ‰ | ˆ ¡}
|
S ) Nr Úcuda)Údevicer' r c s, g | ]$\}}ˆ ||d dd…f d¡‘qS )r' Nr )r( )Ú.0r3 r4 ©Úoutputr% r& Ú
<listcomp>J s z5BiLSTM_TextClassification.forward.<locals>.<listcomp>)Údim)Úlenr r r Úzerosr r ÚtoÚpermuter r/ r+ r r r5 r! ) r" ÚxZ input_seqr1 Ú
batch_sizeZh_0Zc_0Zfinal_hidden_stateZfinal_cell_stater0 Úlogitsr% r9 r& Úforward8 s
z!BiLSTM_TextClassification.forward)FN)Ú__name__Ú
__module__Ú __qualname__r
r5 rD Ú
__classcell__r% r% r# r& r s
ÿr )r r ÚModuler r% r% r% r& Ú<module> s | 2,695 | Python | .py | 30 | 88.766667 | 247 | 0.46099 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,747 | mobilenet_v2.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/mobilenet_v2.cpython-38.pyc | U
”jfc ã @ sv d dl mZ d dlmZ ddgZddiZddd„ZG d d
„ d
ejƒZG d d „ d ej ƒZ
G d
d„ dej ƒZ ddd„Z dS )é )Únn)Úload_state_dict_from_urlÚ MobileNetV2Ú mobilenet_v2z=https://download.pytorch.org/models/mobilenet_v2-b0353104.pthNc C sB |dkr |}t |t| |d ƒ| | ƒ}|d| k r>||7 }|S )aD
This function is taken from the original tf repo.
It ensures that all layers have a channel number that is divisible by 8
It can be seen here:
https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
:param v:
:param divisor:
:param min_value:
:return:
Né gÍÌÌÌÌÌì?)ÚmaxÚint)ÚvÚdivisorÚ min_valueÚnew_v© r
õQ D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\trainmodel\mobilenet_v2.pyÚ_make_divisible
s r c s e Zd Zd‡ fdd„ Z‡ ZS )Ú
ConvBNReLUé é Nc sR |d d }|d krt j}tt| ƒ t j||||||dd�||ƒt jdd�¡ d S )Nr r F)ÚgroupsÚbiasT)Úinplace)r Ú BatchNorm2dÚsuperr Ú__init__ÚConv2dÚReLU6)ÚselfÚ in_planesÚ
out_planesÚ kernel_sizeÚstrider Ú
norm_layerÚpadding©Ú __class__r
r r " s
ýzConvBNReLU.__init__)r r r N)Ú__name__Ú
__module__Ú __qualname__r Ú
__classcell__r
r
r" r r ! s r c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )ÚInvertedResidualNc s¸ t t| ƒ ¡ || _|dks t‚|d kr.tj}tt|| ƒƒ}| jdkoN||k| _ g }|dkrt|
t ||d|d�¡ | t |||||d�tj
||ddddd�||ƒg¡ tj|Ž | _d S )N)r r r ©r r )r r r r F)r )r r( r r ÚAssertionErrorr r r ÚroundÚuse_res_connectÚappendr Úextendr Ú
SequentialÚconv)r ÚinpÚoupr Ú expand_ratior Ú
hidden_dimÚlayersr" r
r r . s ûzInvertedResidual.__init__c C s" | j r|| |¡ S | |¡S d S ©N)r, r0 ©r Úxr
r
r ÚforwardF s zInvertedResidual.forward)N)r$ r% r& r r9 r' r
r
r" r r( - s r( c s. e Zd Zd ‡ fdd„ Zdd„ Zd d
„ Z‡ ZS ) r éè ç ð?Né c s0 t t| ƒ ¡ |dkrt}|dkr(tj}d}d}|dkr‚ddddgddddgddd dgdd
d dgdd d dgdd
d dgddddgg}t|ƒdksžt|d ƒd kr¬td |¡ƒ‚t || |ƒ}t |t
d|ƒ |ƒ| _ t d |d|d�g} |D ]X\}
} } }
t | | |ƒ}t
| ƒD ]4}|dk�r|
nd}| |||||
|d�¡ |}�qqæ| t || j d|d�¡ tj| Ž | _t d¡| _t | j |¡| _| ¡ D ]¢}t|tjƒ�rÈtjj|jdd� |jdk �r(tj |j¡ n`t|tjtj fƒ�rútj |j¡ tj |j¡ n.t|tjƒ�rˆtj |jdd¡ tj |j¡ �qˆdS )aA
MobileNet V2 main class
Args:
num_classes (int): Number of classes
width_mult (float): Width multiplier - adjusts number of channels in each layer by this amount
inverted_residual_setting: Network structure
round_nearest (int): Round the number of channels in each layer to be a multiple of this number
Set to 1 to turn off rounding
block: Module specifying inverted residual building block for mobilenet
norm_layer: Module specifying the normalization layer to use
Né i r é é é r r é@ é é` é i@ r zIinverted_residual_setting should be non-empty or a 4-element list, got {}r; )r r )r3 r r) gš™™™™™É?Úfan_out)Úmodeg{®Gáz„?) r r r r( r r ÚlenÚ
ValueErrorÚformatr r Ú last_channelr Úranger- r/ ÚfeaturesÚDropoutÚdropoutÚLinearÚfcÚmodulesÚ
isinstancer ÚinitÚkaiming_normal_Úweightr Úzeros_Ú GroupNormÚones_Únormal_)r Ú num_classesÚ
width_multÚinverted_residual_settingÚ
round_nearestÚblockr Ú
input_channelrJ rL ÚtÚcÚnÚsÚoutput_channelÚir Úmr" r
r r N sX
ø ÿ
zMobileNetV2.__init__c C s> | |¡}tj |d¡ |jd d¡}| |¡}| |¡}|S )Nr r éÿÿÿÿ)rL r Ú
functionalÚadaptive_avg_pool2dÚreshapeÚshaperN rP r7 r
r
r Ú
_forward_implŸ s
zMobileNetV2._forward_implc C s
| |¡S r6 )rl r7 r
r
r r9 © s zMobileNetV2.forward)r: r; Nr< NN)r$ r% r& r rl r9 r' r
r
r" r r M s úQ
FTc K sd t f |Ž}| r`ttd |d�}i }| ¡ D ]*\}}d|krD|||< q*||| dd¡< q*| |¡ |S )aC
Constructs a MobileNetV2 architecture from
`"MobileNetV2: Inverted Residuals and Linear Bottlenecks" <https://arxiv.org/abs/1801.04381>`_.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
progress (bool): If True, displays a progress bar of the download to stderr
r )ÚprogressÚ
classifierz classifier.1rP )r r Ú
model_urlsÚitemsÚreplaceÚload_state_dict)Ú
pretrainedrm ÚkwargsÚmodelÚ
state_dictÚnew_dictÚkr r
r
r r s
ÿ
)N)FT)
Útorchr Z torch.hubr Ú__all__ro r r/ r ÚModuler( r r r
r
r
r Ú<module> s ÿ
` | 5,683 | Python | .py | 70 | 77.585714 | 401 | 0.472287 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,748 | models.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/trainmodel/__pycache__/models.cpython-39.pyc | a
°“bcZg ã @ sä d dl Z d dlmZ d dlm mZ d dlZd dlZd dlm Z d dl
m Z d dl Z
d dlmZmZ d dlmZmZmZmZ dZG dd„ dejƒZG d d
„ d
ejƒZG d d „ d ejƒZG d
d„ dejƒZG dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ G dd„ dejƒZ dd„ Z!G dd „ d ejƒZ"G d d „ d ejƒZ#G d d „ d ejƒZ$G d!d"„ d"ejƒZ%G d#d$„ d$ejƒZ&G d%d&„ d&ejƒZ'G d'd(„ d(ejƒZ(G d)d*„ d*ejƒZ)G d+d,„ d,ejƒZ*G d-d.„ d.ejƒZ+dS )/é N)Úpartial)Ú OrderedDict)ÚIMAGENET_DEFAULT_MEANÚIMAGENET_DEFAULT_STD)Ú
StdConv2dSameÚDropPathÚ to_2tupleÚ
trunc_normal_é c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú
LocalModelc s t t| ƒ ¡ || _|| _d S ©N)Úsuperr Ú__init__ÚbaseÚ predictor)Úselfr r ©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/trainmodel/models.pyr s zLocalModel.__init__c C s | |¡}| |¡}|S r )r r ©r ÚxÚoutr r r Úforward s
zLocalModel.forward©Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )Ú
LocalModel_ptc s t t| ƒ ¡ || _|| _d S r )r
r r Ú generatorr )r r r r r r r # s zLocalModel_pt.__init__c C s | |¡}| |¡}|S r )r r r r r r r ) s
zLocalModel_pt.forwardr r r r r r " s r c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚLocalModel_repptc s$ t t| ƒ ¡ || _|| _|| _d S r )r
r! r r r r )r r r r r r r r 0 s zLocalModel_reppt.__init__c C s" | |¡}| |¡}| |¡}|S r )r r r r r r r r 7 s
zLocalModel_reppt.forwardr r r r r r! / s r! c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú FedAvgCNNé é
é c
s� t ƒ ¡ t tj|dddddd�tjdd�tjdd �¡| _t tjdd
ddddd�tjdd�tjdd �¡| _t t |d ¡tjdd�¡| _
t d |¡| _ d S ) Né é r r# T)Ú kernel_sizeÚpaddingÚstrideÚbias©Úinplace)é r. ©r( é@ i ) r
r ÚnnÚ
SequentialÚConv2dÚReLUÚ MaxPool2dÚconv1Úconv2ÚLinearÚfc1Úfc)r Ú in_featuresÚ num_classesÚdimr r r r ` s8
û
ø
û
ø
şzFedAvgCNN.__init__c C s8 | |¡}| |¡}t |d¡}| |¡}| |¡}|S )Nr# )r6 r7 ÚtorchÚflattenr9 r: r r r r r | s
zFedAvgCNN.forward)r# r$ r% r r r r r r" _ s r" c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú FedAvgMLPé r$ éÈ c s8 t ƒ ¡ t ||¡| _t ||¡| _tjdd�| _d S )NTr, )r
r r1 r8 r9 Úfc2r4 Úact)r r; r< Ú
hidden_dimr r r r ˆ s
zFedAvgMLP.__init__c C s: |j dkr | | d¡d¡}| | |¡¡}| |¡}|S )Né r éÿÿÿÿ)ÚndimÚviewÚsizerD r9 rC ©r r r r r r � s
zFedAvgMLP.forward)rA r$ rB r r r r r r@ ‡ s r@ c s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚNetc sj t t| ƒ ¡ t dtdd¡| _t tddd¡| _t d¡| _ t d¡| _
t dd¡| _ t dd¡| _
d S ) Nr# r. r& g Ğ?ç à?i H é€ r$ )r
rL r r1 r3 Ú
batch_sizer6 r7 ÚDropoutÚdropout1Údropout2r8 r9 r: )r r r r r ˜ s z Net.__init__c C s� | |¡}t ¡ |ƒ}t dd¡|ƒ}| |¡}| |¡}t ¡ |ƒ}t dd¡|ƒ}| |¡}t |d¡}| |¡}t ¡ |ƒ}|
|¡}t j |dd�}|S )Nr. r# ©r= )
r6 r1 r4 r5 rQ r7 rR r> r? r9 r: ÚFÚ log_softmax©r r Úoutputr r r r ¡ s
z Net.forwardr r r r r rL — s rL c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )Ú
Mclr_LogisticrA r$ c s t t| ƒ ¡ t ||¡| _d S r )r
rX r r1 r8 r: )r Ú input_dimr< r r r r ´ s zMclr_Logistic.__init__c C s( t |d¡}| |¡}tj|dd�}|S ©Nr# rS )r> r? r: rT rU rV r r r r ¸ s
zMclr_Logistic.forward)rA r$ r r r r r rX ³ s rX c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚDNNrA éd r$ c s. t t| ƒ ¡ t ||¡| _t ||¡| _d S r )r
r[ r r1 r8 r9 r: )r rY Zmid_dimr< r r r r Á s z DNN.__init__c C s8 t |d¡}t | |¡¡}| |¡}tj|dd�}|S rZ )r> r? rT Úrelur9 r: rU rK r r r r Æ s
z DNN.forward)rA r\ r$ r r r r r r[ À s r[ c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS )ÚCifarNetr$ c sr t t| ƒ ¡ t ddd¡| _t dd¡| _t dtd¡| _ t
td d d¡| _ t
dd¡| _ t
d|¡| _
d S )Né é r' r. éx éT )r
r^ r r1 r3 r6 r5 ÚpoolrO r7 r8 r9 rC r: )r r< r r r r Ğ s zCifarNet.__init__c C s| | t | |¡¡¡}| t | |¡¡¡}| dtd d ¡}t | |¡¡}t | |¡¡}| |¡}tj
|dd�}|S )NrG r' r# rS ) rc rT r] r6 r7 rI rO r9 rC r: rU rK r r r r Ù s
zCifarNet.forward)r$ r r r r r r^ Ï s r^ c C s | j j}| d¡dks$| d¡dkrBtj | j¡ tj | j¡ nZ| d¡dkrrtj | jdd¡ tj | j¡ n*| d¡dkrœtj
| j¡ tj | j¡ d S )Nr3 rG ÚConvTranspose2dZ BatchNormg ğ?g{®Gáz”?r8 ) r r Úfindr1 ÚinitÚkaiming_uniform_ÚweightÚzeros_r+ Únormal_Úxavier_normal_)ÚmÚ classnamer r r Ú init_weights s rn c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) Ú PadPrompterr# é Nc s´ t t| ƒ ¡ |}|}|| _|| _||d | _t t d| j||g¡¡| _
t t d| j||g¡¡| _ t t d| j||d |g¡¡| _ t t d| j||d |g¡¡| _
d S )Nr. r# )r
ro r ÚargsÚinchanelÚ base_sizer1 Ú Parameterr> ÚrandnÚpad_upÚpad_downÚpad_leftÚ pad_right)r rr Úpad_sizeÚ
image_sizerq r r r r s $zPadPrompter.__init__c C sn t d| j| j| j¡ | jj¡}t j| j|| j gdd�}t j| j
|| j gdd�}t | d¡|g ¡}|| S )Nr# r_ rS r. r )
r> Úzerosrr rs Útorq ÚdeviceÚcatrx ry rv rw rJ )r r r Úpromptr r r r ) s
zPadPrompter.forward)r# r# rp Nr r r r r ro s ro c s& e Zd Zd ‡ fdd„ Zdd„ Z‡ ZS )
ÚLeNeté é r$ Nc
sÌ t t| ƒ ¡ t tjdddd�t d¡t ¡ tjdddd�tjdd�t d¡t ¡ ¡| _ tj
|d d
�| _ tj dd�| _
t ||¡| _| j t¡ t ||¡| _|d kr¼tjj| jd d
�| _| j t¡ d S )Nr# é r' r/ r. é2 rM ©ÚpT)ÚaffineÚwnrh )Úname)r
r� r r1 r2 r3 r5 r4 Ú Dropout2dÚ conv_paramsÚ BatchNorm1dÚbnrP Údropoutr8 Ú
bottleneckÚapplyrn r: ÚutilsÚ weight_norm)r Ú feature_dimZbottleneck_dimr< Ziswnr r r r 4 s$
ù zLeNet.__init__c C sV | |¡}| | d¡d¡}| |¡}| |¡}| |¡}| |¡}tj|dd�}|S ©Nr rG r# rS ) rŒ rI rJ r� r� r� r: rT rU rK r r r r I s
z
LeNet.forward)r‚ rƒ r$ Nr r r r r r� 3 s r� c s& e Zd Zd ‡ fdd„ Zd d
„ Z‡ ZS ) ÚLSTMNetr. Fçš™™™™™É?r éK� r$ c s` t ƒ ¡ t |¡| _t |||¡| _tj|||||dd�| _|rJ|d n|}t ||¡| _
d S )NT)Ú
input_sizeÚ hidden_sizeÚ
num_layersÚ
bidirectionalr� Ú batch_firstr. ) r
r r1 rP r� Ú EmbeddingÚ embeddingÚLSTMÚlstmr8 r: ) r rE r› rœ r� Ú padding_idxÚ
vocab_sizer< Údimsr r r r s s
ûzLSTMNet.__init__c C s’ |\}}| |¡}tjjj||ddd�}| |¡\}\}}tjjj|dd�\} }
t | d d …dd d …f ¡} | | ¡} |
| ¡} t j | dd�} | S )NTF)r� Úenforce_sorted)r� rG r# rS )
rŸ r1 r’ ÚrnnÚpack_padded_sequencer¡ Úpad_packed_sequencer> Úrelu_r� r: rT rU ) r r ÚtextÚ text_lengthsZembeddedZpacked_embeddedZ
packed_outputÚhiddenÚcellr Z out_lengthsr r r r ‚ s
zLSTMNet.forward)r. Fr— r r˜ r$ r r r r r r– r s ÿr– c s& e Zd Zd‡ fdd„ Zdd„ Z‡ ZS ) ÚfastTextr r˜ r$ c s> t t| ƒ ¡ t |||¡| _t ||¡| _t ||¡| _d S r ) r
r® r r1 r� rŸ r8 r9 r: )r rE r¢ r£ r< r r r r ˜ s zfastText.__init__c C s> |\}}| |¡}| | d¡¡}| |¡}tj|dd�}|S rZ )rŸ r9 Úmeanr: rT rU )r r rª r« Ú
embedded_sentÚhÚzr r r r r ¤ s
zfastText.forward)r r˜ r$ r r r r r r® — s r® c s8 e Zd Zdg d¢dddddf‡ fdd „ Zd
d „ Z‡ ZS ) ÚTextCNNr\ )r_ rF r' rB gš™™™™™é?r r˜ r$ c sæ t t| ƒ ¡ t |||¡| _t tj|||d d�t ¡ t ||d d ¡¡| _
t tj|||d d�t ¡ t ||d d ¡¡| _ t tj|||d d�t ¡ t ||d d ¡¡| _ t
|¡| _t |t|ƒ |¡| _d S )Nr )Ú in_channelsÚ out_channelsr( r# r. )r
r³ r r1 r� rŸ r2 ÚConv1dr4 Ú MaxPool1dr6 r7 Úconv3rP r� r8 Úlenr: ) r rE Ú num_channelsr( Úmax_lenr� r¢ r£ r< r r r r ± s& ııı zTextCNN.__init__c C s„ |\}}| |¡ ddd¡}| |¡ d¡}| |¡ d¡}| |¡ d¡}t |||fd¡}| |¡} | | ¡}
t
j |
dd�}
|
S )Nr r. r# rS ) rŸ Úpermuter6 Úsqueezer7 r¸ r> r r� r: rT rU ) r r rª r« r° Z conv_out1Z conv_out2Z conv_out3Zall_outZfinal_feature_mapr r r r r Ï s
zTextCNN.forwardr r r r r r³ ° s ÿ r³ c s* e Zd ZdZd
‡ fdd„ Zdd „ Z‡ ZS ) Ú
PatchEmbedz{
Image to Patch Embedding
CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
éà r
r_ é c sd t ƒ ¡ t|ƒ}t|ƒ}|d |d |d |d }|| _|| _|| _tj||||d�| _d S )Nr# r )r( r* ) r
r r Úimg_sizeÚ
patch_sizeÚ num_patchesr1 r3 Úproj)r rÁ r Úin_chansÚ embed_dimrà r r r r æ s
zPatchEmbed.__init__c
C st |j \}}}}|| jd kr*|| jd ksXJ d|› d|› d| jd › d| jd › d� ƒ‚| |¡ d¡ dd¡}|S )Nr r# zInput image size (Ú*z) doesn't match model (z).r. )ÚshaperÁ rÄ r? Ú transpose)r r ÚBÚCÚHÚWr r r r ñ s (ÿzPatchEmbed.forward)r¿ r
r_ rÀ ©r r r Ú__doc__r r r r r r r r¾ à s r¾ c s4 e Zd ZdZddejdf‡ fdd„ Zdd„ Z‡ ZS )ÚFFNz�
FFN (from timm)
:param in_features:
:param hidden_features:
:param out_features:
:param act_layer:
:param drop:
Nç c sN t ƒ ¡ |p|}|p|}t ||¡| _|ƒ | _t ||¡| _t |¡| _d S r ) r
r r1 r8 r9 rD rC rP Údrop)r r; Úhidden_featuresÚ out_featuresÚ act_layerrÒ r r r r s
z FFN.__init__c C s6 | |¡}| |¡}| |¡}| |¡}| |¡}|S r )r9 rD rÒ rC rK r r r r s
z FFN.forward) r r r rÏ r1 ÚGELUr r r r r r r rĞ ş s rĞ c s* e Zd ZdZd
‡ fdd„ Zdd „ Z‡ ZS ) Ú Attentiona�
qkv Transform + MSA(MHSA) (from timm)
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim=CNN feature dim, because the patch size is 1x1
:param num_heads:
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param attn_drop: dropout rate after MHSA
:param proj_drop:
é FNrÑ c sf t ƒ ¡ || _|| }|p"|d | _tj||d |d�| _t |¡| _t ||¡| _ t |¡| _
d S )Ng à¿r_ )r+ ) r
r Ú num_headsÚscaler1 r8 ÚqkvrP Ú attn_droprÄ Ú proj_drop)r r= rÙ Úqkv_biasÚqk_scalerÜ rİ Úhead_dimr r r r - s
zAttention.__init__c
C s´ |j \}}}| |¡ ||d| j|| j ¡ ddddd¡}|d |d |d }}}|| dd¡ | j } | jdd�} | | ¡} | | dd¡ |||¡}| |¡}|
|¡}|S ) Nr_ r. r r# rF éşÿÿÿrG rS ) rÈ rÛ ÚreshaperÙ r¼ rÉ rÚ ÚsoftmaxrÜ rÄ rİ )
r r ÚbatchZ patch_numberZ patch_dimrÛ ÚqÚkÚvÚattnr r r r : s ÿ
ÿ
zAttention.forward)rØ FNrÑ rÑ rÎ r r r r r× s
r× c s: e Zd Zddddddejejf‡ fdd„ Zdd„ Z‡ ZS ) ÚBlockç @FNrÑ c sp t ƒ ¡ |
|ƒ| _t||||||d�| _|dkr:t|ƒnt ¡ | _|
|ƒ| _ t
|| ƒ} t || | |d�| _ dS )aê
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim
:param num_heads:
:param mlp_ratio: FFN
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param drop:
:param attn_drop: dropout rate after Attention
:param drop_path: dropout rate after sd
:param act_layer: FFN act
:param norm_layer: Pre Norm
)rÙ rŞ rß rÜ rİ rÑ )r; rÓ rÕ rÒ N)
r
r Únorm1r× rè r r1 ÚIdentityÚ drop_pathÚnorm2ÚintrĞ Úmlp) r r= rÙ Ú mlp_ratiorŞ rß rÒ rÜ rí rÕ Ú
norm_layerZmlp_hidden_dimr r r r W s
ÿ
zBlock.__init__c C s8 || | | |¡¡¡ }|| | | |¡¡¡ }|S r )rí rè rë rğ rî rK r r r r v s z
Block.forward) r r r r1 rÖ Ú LayerNormr r r r r r r ré U s
ÿ ré c sR e Zd ZdZddddddddd d
d d d ed
d
f‡ fd d
„ Zdd„ Zdd„ Z‡ ZS )ÚVisionTransformerz¬
Vision Transformer
A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
- https://arxiv.org/abs/2010.11929
r& r
r_ r$ rÀ é rê TNrÑ c
sX t ƒ ¡ || _ˆ | _| _d| _ˆp2ttjdd�‰ˆ p<tj ‰ ||||ˆd�| _
| j
j }t t
ddˆ¡¡| _t t
d|| j ˆ¡¡| _tjˆd�| _dd„ t
d|
|¡D ƒ‰tj‡ ‡‡‡‡‡‡‡‡f d d„t|ƒD ƒ� | _ˆˆƒ| _|
�r |
| _t td
t ˆ|
¡fd t ¡ fgƒ¡| _n
t ¡ | _| jdk�rDt | j| j¡nt ¡ | _ d | _ d S )
aš
Args:
img_size (int, tuple): input image size
patch_size (int, tuple): patch size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (int): embedding dimension
depth (int): depth of transformer
num_heads (int): number of attention heads
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
embed_layer (nn.Module): patch embedding layer
norm_layer: (nn.Module): normalization layer
r# g�íµ ÷Æ°>)Úeps)rÁ r rÅ rÆ r† c S s g | ] }| ¡ ‘qS r )Úitem)Ú.0r r r r Ú
<listcomp>® ó z.VisionTransformer.__init__.<locals>.<listcomp>r c
s* g | ]"}t ˆˆˆˆˆˆˆ| ˆˆ d � ‘qS )) r= rÙ rñ rŞ rÒ rÜ rí rò rÕ )ré )rø Úi© rÕ Úattn_drop_rateZdprÚ drop_raterÆ rñ rò rÙ rŞ r r rù ± s ş ÿr: rD N) r
r r< Ú num_featuresrÆ Z
num_tokensr r1 ró rÖ Ú patch_embedrà rt r> r| Ú cls_tokenÚ pos_embedrP Úpos_dropÚlinspacer2 ÚrangeÚblocksÚnormr r8 ÚTanhÚ
pre_logitsrì ÚheadZ head_dist)r rÁ r rÅ r< rÆ ÚdepthrÙ rñ rŞ Úrepresentation_sizerş rı Zdrop_path_rateZ embed_layerrò rÕ rà r rü r r † s6
ÿ ı
ş
&zVisionTransformer.__init__c C sZ | |¡}| j |jd dd¡}tj||fdd�}| || j ¡}| |¡}| |¡}|S r• )
r r ÚexpandrÈ r> r r r r r )r r r r r r Úforward_featuresÇ s
z"VisionTransformer.forward_featuresc C s. | |¡}| |d d …df ¡}| |¡}|S )Nr )r r r
rK r r r r Ò s
zVisionTransformer.forward) r r r rÏ r¾ r r r r r r r r rô s şA rô ),r> Útorch.nnr1 Útorch.nn.functionalÚ
functionalrT ÚmathÚloggingÚ functoolsr Ú collectionsr ÚnumpyÚnpZ timm.datar r Ztimm.models.layersr r r r rO ÚModuler r r! r" r@ rL rX r[ r^ rn ro r� r– r® r³ r¾ rĞ r× ré rô r r r r Ú<module> s<
0(
@
?%0 "5* | 19,577 | Python | .py | 207 | 91.603865 | 633 | 0.364153 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,749 | vit-checkpoint.py | hkgdifyu_pFedPT/system/flcore/trainmodel/.ipynb_checkpoints/vit-checkpoint.py | import torch
from torch import nn
from einops import rearrange, repeat
from einops.layers.torch import Rearrange
# helpers
def pair(t):
return t if isinstance(t, tuple) else (t, t)
# classes
class PreNorm(nn.Module):
def __init__(self, dim, fn):
super().__init__()
self.norm = nn.LayerNorm(dim)
self.fn = fn
def forward(self, x, **kwargs):
return self.fn(self.norm(x), **kwargs)
class FeedForward(nn.Module):
def __init__(self, dim, hidden_dim, dropout = 0.):
super().__init__()
self.net = nn.Sequential(
nn.Linear(dim, hidden_dim),
nn.GELU(),
nn.Dropout(dropout),
nn.Linear(hidden_dim, dim),
nn.Dropout(dropout)
)
def forward(self, x):
return self.net(x)
class Attention(nn.Module):
def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.1):
super().__init__()
inner_dim = dim_head * heads
project_out = not (heads == 1 and dim_head == dim)
self.heads = heads
self.scale = dim_head ** -0.5
self.attend = nn.Softmax(dim = -1)
self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
self.to_out = nn.Sequential(
nn.Linear(inner_dim, dim),
nn.Dropout(dropout)
) if project_out else nn.Identity()
def forward(self, x):
qkv = self.to_qkv(x).chunk(3, dim = -1)
q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
attn = self.attend(dots)
out = torch.matmul(attn, v)
# print("out: ", out)
# print("QKV output dimension: ",out.shape)
# for i in range(8):
# print("Head "+str(i+1)+": ")
# print("Total mean: ",torch.mean(out[0][i]))
# print("QKV output: ",out[0][i])
# print("Isinstance mean: ",torch.mean(out[0][i],dim=0))
# print("Whole activation: ",out)
out = rearrange(out, 'b h n d -> b n (h d)')
return self.to_out(out)
class Transformer(nn.Module):
def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
super().__init__()
self.layers = nn.ModuleList([])
for _ in range(depth):
self.layers.append(nn.ModuleList([
PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
]))
def forward(self, x):
ll = 0
for attn, ff in self.layers:
ll += 1
x = attn(x) + x
x = ff(x) + x
return x
class ViT(nn.Module):
def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
super().__init__()
image_height, image_width = pair(image_size)
patch_height, patch_width = pair(patch_size)
assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
num_patches = (image_height // patch_height) * (image_width // patch_width)
patch_dim = channels * patch_height * patch_width
assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
self.to_patch_embedding = nn.Sequential(
Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
nn.Linear(patch_dim, dim),
)
self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
self.dropout = nn.Dropout(emb_dropout)
self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
self.pool = pool
self.to_latent = nn.Identity()
self.norm = nn.LayerNorm(dim)
self.fc = nn.Linear(dim, num_classes)
def forward(self, img):
x = self.to_patch_embedding(img)
b, n, _ = x.shape
cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
x = torch.cat((cls_tokens, x), dim=1)
x += self.pos_embedding[:, :(n + 1)]
x = self.dropout(x)
x = self.transformer(x)
x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
x = self.to_latent(x)
x = self.norm(x)
x = self.fc(x)
return x
def produce_feature(self, img):
x = self.to_patch_embedding(img)
b, n, _ = x.shape
cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
x = torch.cat((cls_tokens, x), dim=1)
x += self.pos_embedding[:, :(n + 1)]
x = self.dropout(x)
x = self.transformer(x)
x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
x = self.to_latent(x)
return x
def cal_feature(self, img):
x = self.to_patch_embedding(img)
b, n, _ = x.shape
cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
x = torch.cat((cls_tokens, x), dim=1)
x += self.pos_embedding[:, :(n + 1)]
x = self.dropout(x)
x = self.transformer(x)
return x
def Show_detail(self, img):
x = self.to_patch_embedding(img)
b, n, _ = x.shape
cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
x = torch.cat((cls_tokens, x), dim=1)
x += self.pos_embedding[:, :(n + 1)]
x = self.dropout(x)
x = self.transformer(x)
return x | 5,687 | Python | .py | 135 | 33.274074 | 166 | 0.548481 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,750 | models-checkpoint.py | hkgdifyu_pFedPT/system/flcore/trainmodel/.ipynb_checkpoints/models-checkpoint.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import logging
from functools import partial
from collections import OrderedDict
import numpy as np
from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
from timm.models.layers import StdConv2dSame, DropPath, to_2tuple, trunc_normal_
batch_size = 16
class LocalModel(nn.Module):
def __init__(self, base, predictor):
super(LocalModel, self).__init__()
self.base = base
self.predictor = predictor
def forward(self, x):
out = self.base(x)
out = self.predictor(out)
return out
class LocalModel_pt(nn.Module):
def __init__(self, generator, base):
super(LocalModel_pt, self).__init__()
self.generator = generator
self.base = base
def forward(self, x):
out = self.generator(x)
out = self.base(out)
return out
class LocalModel_reppt(nn.Module):
def __init__(self, generator, base, predictor):
super(LocalModel_reppt, self).__init__()
self.generator = generator
self.base = base
self.predictor = predictor
def forward(self, x):
out = self.generator(x)
out = self.base(out)
out = self.predictor(out)
return out
# # https://github.com/katsura-jp/fedavg.pytorch/blob/master/src/models/cnn.py
# class FedAvgCNN(nn.Module):
# def __init__(self, in_features=1, num_classes=10, dim=1024):
# super().__init__()
# self.conv1 = nn.Conv2d(in_features,
# 32,
# kernel_size=5,
# padding=0,
# stride=1,
# bias=True)
# self.conv2 = nn.Conv2d(32,
# 64,
# kernel_size=5,
# padding=0,
# stride=1,
# bias=True)
# self.fc1 = nn.Linear(dim, 512)
# self.fc = nn.Linear(512, num_classes)
# self.act = nn.ReLU(inplace=True)
# self.maxpool = nn.MaxPool2d(kernel_size=(2, 2))
# def forward(self, x):
# x = self.act(self.conv1(x))
# x = self.maxpool(x)
# x = self.act(self.conv2(x))
# x = self.maxpool(x)
# x = torch.flatten(x, 1)
# x = self.act(self.fc1(x))
# x = self.fc(x)
# return x
class FedAvgCNN(nn.Module):
def __init__(self, in_features=1, num_classes=10, dim=1024):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_features,
32,
kernel_size=5,
padding=0,
stride=1,
bias=True),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=(2, 2))
)
self.conv2 = nn.Sequential(
nn.Conv2d(32,
64,
kernel_size=5,
padding=0,
stride=1,
bias=True),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=(2, 2))
)
self.fc1 = nn.Sequential(
nn.Linear(dim, 512),
nn.ReLU(inplace=True)
)
self.fc = nn.Linear(512, num_classes)
def forward(self, x):
out = self.conv1(x)
out = self.conv2(out)
out = torch.flatten(out, 1)
out = self.fc1(out)
out = self.fc(out)
return out
# ====================================================================================================================
# https://github.com/katsura-jp/fedavg.pytorch/blob/master/src/models/mlp.py
class FedAvgMLP(nn.Module):
def __init__(self, in_features=784, num_classes=10, hidden_dim=200):
super().__init__()
self.fc1 = nn.Linear(in_features, hidden_dim)
self.fc2 = nn.Linear(hidden_dim, num_classes)
self.act = nn.ReLU(inplace=True)
def forward(self, x):
if x.ndim == 4:
x = x.view(x.size(0), -1)
x = self.act(self.fc1(x))
x = self.fc2(x)
return x
# ====================================================================================================================
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, batch_size, 2, 1)
self.conv2 = nn.Conv2d(batch_size, 32, 2, 1)
self.dropout1 = nn.Dropout(0.25)
self.dropout2 = nn.Dropout(0.5)
self.fc1 = nn.Linear(18432, 128)
self.fc = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = nn.ReLU()(x)
x = nn.MaxPool2d(2, 1)(x)
x = self.dropout1(x)
x = self.conv2(x)
x = nn.ReLU()(x)
x = nn.MaxPool2d(2, 1)(x)
x = self.dropout2(x)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = nn.ReLU()(x)
x = self.fc(x)
output = F.log_softmax(x, dim=1)
return output
# ====================================================================================================================
class Mclr_Logistic(nn.Module):
def __init__(self, input_dim=1*28*28, num_classes=10):
super(Mclr_Logistic, self).__init__()
self.fc = nn.Linear(input_dim, num_classes)
def forward(self, x):
x = torch.flatten(x, 1)
x = self.fc(x)
output = F.log_softmax(x, dim=1)
return output
# ====================================================================================================================
class DNN(nn.Module):
def __init__(self, input_dim=1*28*28, mid_dim=100, num_classes=10):
super(DNN, self).__init__()
self.fc1 = nn.Linear(input_dim, mid_dim)
self.fc = nn.Linear(mid_dim, num_classes)
def forward(self, x):
x = torch.flatten(x, 1)
x = F.relu(self.fc1(x))
x = self.fc(x)
x = F.log_softmax(x, dim=1)
return x
# ====================================================================================================================
class CifarNet(nn.Module):
def __init__(self, num_classes=10):
super(CifarNet, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, batch_size, 5)
self.fc1 = nn.Linear(batch_size * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc = nn.Linear(84, num_classes)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, batch_size * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc(x)
x = F.log_softmax(x, dim=1)
return x
# ====================================================================================================================
# cfg = {
# 'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
# 'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
# 'VGGbatch_size': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
# 'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
# }
# class VGG(nn.Module):
# def __init__(self, vgg_name):
# super(VGG, self).__init__()
# self.features = self._make_layers(cfg[vgg_name])
# self.classifier = nn.Sequential(
# nn.Linear(512, 512),
# nn.ReLU(True),
# nn.Linear(512, 512),
# nn.ReLU(True),
# nn.Linear(512, 10)
# )
# def forward(self, x):
# out = self.features(x)
# out = out.view(out.size(0), -1)
# out = self.classifier(out)
# output = F.log_softmax(out, dim=1)
# return output
# def _make_layers(self, cfg):
# layers = []
# in_channels = 3
# for x in cfg:
# if x == 'M':
# layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
# else:
# layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),
# nn.BatchNorm2d(x),
# nn.ReLU(inplace=True)]
# in_channels = x
# layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
# return nn.Sequential(*layers)
# ====================================================================================================================
def init_weights(m):
classname = m.__class__.__name__
if classname.find('Conv2d') != -1 or classname.find('ConvTranspose2d') != -1:
nn.init.kaiming_uniform_(m.weight)
nn.init.zeros_(m.bias)
elif classname.find('BatchNorm') != -1:
nn.init.normal_(m.weight, 1.0, 0.02)
nn.init.zeros_(m.bias)
elif classname.find('Linear') != -1:
nn.init.xavier_normal_(m.weight)
nn.init.zeros_(m.bias)
class PadPrompter(nn.Module):
def __init__(self,inchanel = 1,pad_size=1,image_size=28,args =None):
super(PadPrompter, self).__init__()
pad_size = pad_size
image_size = image_size
self.args = args
self.inchanel =inchanel
self.base_size = image_size - pad_size*2
self.pad_up = nn.Parameter(torch.randn([1, self.inchanel, pad_size, image_size]))
self.pad_down = nn.Parameter(torch.randn([1, self.inchanel, pad_size, image_size]))
self.pad_left = nn.Parameter(torch.randn([1, self.inchanel, image_size - pad_size*2, pad_size]))
self.pad_right = nn.Parameter(torch.randn([1,self.inchanel, image_size - pad_size*2, pad_size]))
def forward(self, x):
base = torch.zeros(1, self.inchanel, self.base_size, self.base_size).to(self.args.device)
prompt = torch.cat([self.pad_left, base, self.pad_right], dim=3)
prompt = torch.cat([self.pad_up, prompt, self.pad_down], dim=2)
prompt = torch.cat(x.size(0) * [prompt])
return x + prompt
class LeNet(nn.Module):
def __init__(self, feature_dim=50*4*4, bottleneck_dim=256, num_classes=10, iswn=None):
super(LeNet, self).__init__()
self.conv_params = nn.Sequential(
nn.Conv2d(1, 20, kernel_size=5),
nn.MaxPool2d(2),
nn.ReLU(),
nn.Conv2d(20, 50, kernel_size=5),
nn.Dropout2d(p=0.5),
nn.MaxPool2d(2),
nn.ReLU(),
)
self.bn = nn.BatchNorm1d(bottleneck_dim, affine=True)
self.dropout = nn.Dropout(p=0.5)
self.bottleneck = nn.Linear(feature_dim, bottleneck_dim)
self.bottleneck.apply(init_weights)
self.fc = nn.Linear(bottleneck_dim, num_classes)
if iswn == "wn":
self.fc = nn.utils.weight_norm(self.fc, name="weight")
self.fc.apply(init_weights)
def forward(self, x):
x = self.conv_params(x)
x = x.view(x.size(0), -1)
x = self.bottleneck(x)
x = self.bn(x)
x = self.dropout(x)
x = self.fc(x)
x = F.log_softmax(x, dim=1)
return x
# ====================================================================================================================
# class CNNCifar(nn.Module):
# def __init__(self, num_classes=10):
# super(CNNCifar, self).__init__()
# self.conv1 = nn.Conv2d(3, 6, 5)
# self.pool = nn.MaxPool2d(2, 2)
# self.conv2 = nn.Conv2d(6, batch_size, 5)
# self.fc1 = nn.Linear(batch_size * 5 * 5, 120)
# self.fc2 = nn.Linear(120, 100)
# self.fc3 = nn.Linear(100, num_classes)
# # self.weight_keys = [['fc1.weight', 'fc1.bias'],
# # ['fc2.weight', 'fc2.bias'],
# # ['fc3.weight', 'fc3.bias'],
# # ['conv2.weight', 'conv2.bias'],
# # ['conv1.weight', 'conv1.bias'],
# # ]
# def forward(self, x):
# x = self.pool(F.relu(self.conv1(x)))
# x = self.pool(F.relu(self.conv2(x)))
# x = x.view(-1, batch_size * 5 * 5)
# x = F.relu(self.fc1(x))
# x = F.relu(self.fc2(x))
# x = self.fc3(x)
# x = F.log_softmax(x, dim=1)
# return x
# ====================================================================================================================
class LSTMNet(nn.Module):
def __init__(self, hidden_dim, num_layers=2, bidirectional=False, dropout=0.2,
padding_idx=0, vocab_size=98635, num_classes=10):
super().__init__()
self.dropout = nn.Dropout(dropout)
self.embedding = nn.Embedding(vocab_size, hidden_dim, padding_idx)
self.lstm = nn.LSTM(input_size=hidden_dim,
hidden_size=hidden_dim,
num_layers=num_layers,
bidirectional=bidirectional,
dropout=dropout,
batch_first=True)
dims = hidden_dim*2 if bidirectional else hidden_dim
self.fc = nn.Linear(dims, num_classes)
def forward(self, x):
text, text_lengths = x
embedded = self.embedding(text)
#pack sequence
packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths, batch_first=True, enforce_sorted=False)
packed_output, (hidden, cell) = self.lstm(packed_embedded)
#unpack sequence
out, out_lengths = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
out = torch.relu_(out[:,-1,:])
out = self.dropout(out)
out = self.fc(out)
out = F.log_softmax(out, dim=1)
return out
# ====================================================================================================================
class fastText(nn.Module):
def __init__(self, hidden_dim, padding_idx=0, vocab_size=98635, num_classes=10):
super(fastText, self).__init__()
# Embedding Layer
self.embedding = nn.Embedding(vocab_size, hidden_dim, padding_idx)
# Hidden Layer
self.fc1 = nn.Linear(hidden_dim, hidden_dim)
# Output Layer
self.fc = nn.Linear(hidden_dim, num_classes)
def forward(self, x):
text, text_lengths = x
embedded_sent = self.embedding(text)
h = self.fc1(embedded_sent.mean(1))
z = self.fc(h)
out = F.log_softmax(z, dim=1)
return out
# ====================================================================================================================
class TextCNN(nn.Module):
def __init__(self, hidden_dim, num_channels=100, kernel_size=[3,4,5], max_len=200, dropout=0.8,
padding_idx=0, vocab_size=98635, num_classes=10):
super(TextCNN, self).__init__()
# Embedding Layer
self.embedding = nn.Embedding(vocab_size, hidden_dim, padding_idx)
# This stackoverflow thread clarifies how conv1d works
# https://stackoverflow.com/questions/46503816/keras-conv1d-layer-parameters-filters-and-kernel-size/46504997
self.conv1 = nn.Sequential(
nn.Conv1d(in_channels=hidden_dim, out_channels=num_channels, kernel_size=kernel_size[0]),
nn.ReLU(),
nn.MaxPool1d(max_len - kernel_size[0]+1)
)
self.conv2 = nn.Sequential(
nn.Conv1d(in_channels=hidden_dim, out_channels=num_channels, kernel_size=kernel_size[1]),
nn.ReLU(),
nn.MaxPool1d(max_len - kernel_size[1]+1)
)
self.conv3 = nn.Sequential(
nn.Conv1d(in_channels=hidden_dim, out_channels=num_channels, kernel_size=kernel_size[2]),
nn.ReLU(),
nn.MaxPool1d(max_len - kernel_size[2]+1)
)
self.dropout = nn.Dropout(dropout)
# Fully-Connected Layer
self.fc = nn.Linear(num_channels*len(kernel_size), num_classes)
def forward(self, x):
text, text_lengths = x
embedded_sent = self.embedding(text).permute(0,2,1)
conv_out1 = self.conv1(embedded_sent).squeeze(2)
conv_out2 = self.conv2(embedded_sent).squeeze(2)
conv_out3 = self.conv3(embedded_sent).squeeze(2)
all_out = torch.cat((conv_out1, conv_out2, conv_out3), 1)
final_feature_map = self.dropout(all_out)
out = self.fc(final_feature_map)
out = F.log_softmax(out, dim=1)
return out
# ====================================================================================================================
class PatchEmbed(nn.Module): # PatchEmbed from timm
"""
Image to Patch Embedding
CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
super().__init__()
img_size = to_2tuple(img_size)
patch_size = to_2tuple(patch_size)
num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
self.img_size = img_size
self.patch_size = patch_size
self.num_patches = num_patches
self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
def forward(self, x):
B, C, H, W = x.shape
# FIXME look at relaxing size constraints
assert H == self.img_size[0] and W == self.img_size[1], \
f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
# CNN_proj + Rearrange: [B, C, W, H] -> [B, D, Pn_W, Pn_H] -> [B, D, Pn] -> [B, Pn, D]
x = self.proj(x).flatten(2).transpose(1, 2)
# x: (B, 14*14, 768)
return x
class FFN(nn.Module): # Mlp from timm
"""
FFN (from timm)
:param in_features:
:param hidden_features:
:param out_features:
:param act_layer:
:param drop:
"""
def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
self.fc1 = nn.Linear(in_features, hidden_features)
self.act = act_layer()
self.fc2 = nn.Linear(hidden_features, out_features)
self.drop = nn.Dropout(drop)
def forward(self, x):
x = self.fc1(x)
x = self.act(x)
x = self.drop(x)
x = self.fc2(x)
x = self.drop(x)
return x
# MHSA
class Attention(nn.Module): # qkv Transform + MSA(MHSA) (Attention from timm)
"""
qkv Transform + MSA(MHSA) (from timm)
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim=CNN feature dim, because the patch size is 1x1
:param num_heads:
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param attn_drop: dropout rate after MHSA
:param proj_drop:
"""
def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
# NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
self.scale = qk_scale or head_dim ** -0.5
self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
self.attn_drop = nn.Dropout(attn_drop)
self.proj = nn.Linear(dim, dim)
self.proj_drop = nn.Dropout(proj_drop)
def forward(self, x):
# input x.shape = batch, patch_number, patch_dim
batch, patch_number, patch_dim = x.shape
# mlp transform + head split [B, Pn, D] -> [B, Pn, 3D] -> [B, Pn, 3, H, D/H] -> [3, B, H, Pn, D/H]
qkv = self.qkv(x).reshape(batch, patch_number, 3, self.num_heads, patch_dim //
self.num_heads).permute(2, 0, 3, 1, 4)
# 3 [B, H, Pn, D/H]
q, k, v = qkv[0], qkv[1], qkv[2]
# [B, H, Pn, D/H] -> [B, H, Pn, D/H]
attn = (q @ k.transpose(-2, -1)) * self.scale
attn = attn.softmax(dim=-1)
attn = self.attn_drop(attn) # Dropout
# head fusion: [B, H, Pn, D/H] -> [B, Pn, H, D/H] -> [B, Pn, D]
x = (attn @ v).transpose(1, 2).reshape(batch, patch_number, patch_dim)
x = self.proj(x)
x = self.proj_drop(x) # mlp
# output x.shape = batch, patch_number, patch_dim
return x
# Encoder_Block
class Block(nn.Module): # teansformer Block from timm
def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm):
"""
# input x.shape = batch, patch_number, patch_dim
# output x.shape = batch, patch_number, patch_dim
:param dim: dim
:param num_heads:
:param mlp_ratio: FFN
:param qkv_bias:
:param qk_scale: by default head_dim ** -0.5 (squre root)
:param drop:
:param attn_drop: dropout rate after Attention
:param drop_path: dropout rate after sd
:param act_layer: FFN act
:param norm_layer: Pre Norm
"""
super().__init__()
# Pre Norm
self.norm1 = norm_layer(dim) # Transformer used the nn.LayerNorm
self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop,
proj_drop=drop)
# NOTE from timm: drop path for stochastic depth, we shall see if this is better than dropout here
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() # stochastic depth
# Add & Norm
self.norm2 = norm_layer(dim)
# FFN
mlp_hidden_dim = int(dim * mlp_ratio)
self.mlp = FFN(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
def forward(self, x):
# MHSA + Res_connection
x = x + self.drop_path(self.attn(self.norm1(x)))
# FFN + Res_connection
x = x + self.drop_path(self.mlp(self.norm2(x)))
return x
class VisionTransformer(nn.Module): # From timm
"""
Vision Transformer
A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
- https://arxiv.org/abs/2010.11929
"""
def __init__(self, img_size=32, patch_size=16, in_chans=3, num_classes=10, embed_dim=128, depth=8,
num_heads=8, mlp_ratio=2., qkv_bias=True, representation_size=None, drop_rate=0., attn_drop_rate=0.,
drop_path_rate=0., embed_layer=PatchEmbed, norm_layer=None, act_layer=None):
"""
Args:
img_size (int, tuple): input image size
patch_size (int, tuple): patch size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (int): embedding dimension
depth (int): depth of transformer
num_heads (int): number of attention heads
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
embed_layer (nn.Module): patch embedding layer
norm_layer: (nn.Module): normalization layer
"""
super().__init__()
self.num_classes = num_classes
self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
self.num_tokens = 1
norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
act_layer = act_layer or nn.GELU
self.patch_embed = embed_layer(
img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
num_patches = self.patch_embed.num_patches
# Embedding tokens
self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
self.pos_drop = nn.Dropout(p=drop_rate)
# Stochastic Depth Decay rule
dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
# Encoders
self.blocks = nn.Sequential(*[
Block(dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, drop=drop_rate,
attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, act_layer=act_layer)
for i in range(depth)])
# last norm
self.norm = norm_layer(embed_dim)
# Representation layer
if representation_size:
self.num_features = representation_size
self.pre_logits = nn.Sequential(OrderedDict([
('fc', nn.Linear(embed_dim, representation_size)),
('act', nn.Tanh())
]))
else:
self.pre_logits = nn.Identity()
# Classifier head(s)
self.fc = nn.Linear(self.num_features, self.num_classes) if self.num_classes > 0 else nn.Identity()
self.head_dist = None
def forward_features(self, x):
x = self.patch_embed(x)
# print(x.shape,self.pos_embed.shape)
cls_token = self.cls_token.expand(x.shape[0], -1, -1)
x = torch.cat((cls_token, x), dim=1)
x = self.pos_drop(x + self.pos_embed)
x = self.blocks(x)
x = self.norm(x)
return x
def forward(self, x):
x = self.forward_features(x)
x = self.pre_logits(x[:, 0]) # use cls token for cls head [B,1,768]
x = self.fc(x)
return x
# class linear(Function):
# @staticmethod
# def forward(ctx, input):
# return input
# @staticmethod
# def backward(ctx, grad_output):
# return grad_output | 26,452 | Python | .py | 595 | 36.364706 | 123 | 0.531646 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,751 | serverpfedpt.py | hkgdifyu_pFedPT/system/flcore/servers/serverpfedpt.py | from flcore.clients.clientpt import clientPT
from flcore.servers.serverbase import Server
from threading import Thread
import time
import torch
import os
import h5py
import copy
import numpy as np
class PFedPT(Server):
def __init__(self, args, times):
super().__init__(args, times)
# select slow clients
self.set_slow_clients()
self.args = args
self.set_clients(args, clientPT)
self.global_model = copy.deepcopy(args.model.base)
self.diff_pro = []
self.clients_diverge = []
print(f"\nJoin ratio / total clients: {self.join_ratio} / {self.num_clients}")
print("Finished creating server and clients.")
# self.load_model()
self.Budget = []
def train(self):
local_acc = []
for i in range(self.global_rounds+1):
s_t = time.time()
self.selected_clients = self.select_clients()
self.send_models()
if i%self.eval_gap == 0:
print(f"\n-------------Round number: {i}-------------")
print("\nEvaluate global model")
self.evaluate()
temp_diff_pro = 0
for client in self.selected_clients:
temp_diff_pro_client = client.train()
temp_diff_pro = temp_diff_pro +temp_diff_pro_client.item()
print("Averaged prompr difference: {:.4f}".format(temp_diff_pro))
self.diff_pro.append(temp_diff_pro)
diverge_clents =0
for new_param, old_param in zip(self.clients[0].model.generator.parameters(), self.clients[1].model.generator.parameters()):
diff_pro = new_param - old_param
diff_pro = torch.where(diff_pro > 0, diff_pro, torch.zeros_like(diff_pro) - diff_pro)
diverge_clents = diverge_clents+torch.sum(diff_pro)
print("0 and 1 clients difference: {:.4f}".format(diverge_clents.item()))
self.clients_diverge.append(diverge_clents.item())
if i%self.eval_gap == 0:
print("\nEvaluate local model")
self.evaluate(acc=local_acc)
# threads = [Thread(target=client.train)
# for client in self.selected_clients]
# [t.start() for t in threads]
# [t.join() for t in threads]
self.receive_models()
self.aggregate_parameters()
self.Budget.append(time.time() - s_t)
print('-'*25, 'time cost', '-'*25, self.Budget[-1])
print("\nBest global accuracy.")
# self.print_(max(self.rs_test_acc), max(
# self.rs_train_acc), min(self.rs_train_loss))
print(max(self.rs_test_acc))
print("\nAverage time cost per round.")
print(sum(self.Budget[1:])/len(self.Budget[1:]))
print("\nBest local accuracy.")
print(max(local_acc))
self.save_results()
self.save_global_model()
self.save_client_model()
def receive_models(self):
assert (len(self.selected_clients) > 0)
active_train_samples = 0
for client in self.selected_clients:
active_train_samples += client.train_samples
self.uploaded_weights = []
self.uploaded_ids = []
self.uploaded_models = []
for client in self.selected_clients:
self.uploaded_weights.append(client.train_samples / active_train_samples)
self.uploaded_ids.append(client.id)
self.uploaded_models.append(copy.deepcopy(client.model.base))
def save_client_model(self):
model_path = os.path.join("models", self.dataset,"client",self.args.arv1+"*"+self.args.arv2+"*"+self.args.arv3+"*"+self.args.arv4+"*"+self.args.arv5+"*"+self.args.arv6 )
if not os.path.exists(model_path):
os.makedirs(model_path)
for c_idx,c in enumerate(self.clients):
model_path_save = os.path.join(model_path, self.algorithm + "_client" +str(c_idx)+ "_" + str(self.args.num_prompt) + "_" + str(self.args.join_ratio) + "_" + str(self.args.num_clients)+ "_" + str(self.args.plocal_steps) + "_" + str(self.args.global_rounds)+ ".pt")
torch.save(c.model, model_path_save)
def save_results(self):
algo = self.dataset + "_" + self.algorithm
result_path = "../results/"+ self.args.arv1+"*"+self.args.arv2+"*"+self.args.arv3+"*"+self.args.arv4+"*"+self.args.arv5+"*"+self.args.arv6 +"/"
if not os.path.exists(result_path):
os.makedirs(result_path)
if (len(self.rs_test_acc)):
algo =algo + "_" + self.goal + "_" + str(self.times)+ "_" + str(self.args.num_prompt) + "_" + str(self.args.join_ratio) + "_" + str(self.args.num_clients)+ "_" + str(self.args.plocal_steps) + "_" + str(self.args.global_rounds)
file_path = result_path + "{}.h5".format(algo)
print("File path: " + file_path)
with h5py.File(file_path, 'w') as hf:
hf.create_dataset('rs_test_acc', data=self.rs_test_acc)
hf.create_dataset('rs_test_acc_std', data=self.rs_test_acc_std)
hf.create_dataset('rs_test_auc', data=self.rs_test_auc)
hf.create_dataset('rs_train_loss', data=self.rs_train_loss)
hf.create_dataset('diff_pro', data=self.diff_pro)
hf.create_dataset('clients_diverge', data=self.clients_diverge)
def evaluate(self, acc=None, loss=None):
stats = self.test_metrics()
stats_train = self.train_metrics()
test_acc = sum(stats[2]) * 1.0 / sum(stats[1])
test_acc2 = sum(stats[4]) * 1.0 / sum(stats[1])
test_auc = sum(stats[3]) * 1.0 / sum(stats[1])
train_loss = sum(stats_train[2]) * 1.0 / sum(stats_train[1])
accs = [a / n for a, n in zip(stats[2], stats[1])]
aucs = [a / n for a, n in zip(stats[3], stats[1])]
if acc == None:
self.rs_test_acc.append(test_acc)
else:
acc.append(test_acc)
self.rs_test_auc.append(test_auc)
self.rs_test_acc_std.append(np.std(accs))
if loss == None:
self.rs_train_loss.append(train_loss)
else:
loss.append(train_loss)
print("Averaged Train Loss: {:.4f}".format(train_loss))
print("Averaged Test Accurancy: {:.4f}".format(test_acc))
print("Averaged Test oral Accurancy: {:.4f}".format(test_acc2))
print("Averaged Test AUC: {:.4f}".format(test_auc))
# self.print_(test_acc, train_acc, train_loss)
print("Std Test Accurancy: {:.4f}".format(np.std(accs)))
print("Std Test AUC: {:.4f}".format(np.std(aucs)))
def test_metrics(self):
num_samples = []
tot_correct = []
tot_correct2 = []
tot_auc = []
for c in self.clients:
ct, ct2, ns, auc = c.test_metrics()
tot_correct.append(ct * 1.0)
tot_correct2.append(ct2 * 1.0)
tot_auc.append(auc * ns)
num_samples.append(ns)
ids = [c.id for c in self.clients]
return ids, num_samples, tot_correct, tot_auc, tot_correct2 | 7,153 | Python | .py | 142 | 39.802817 | 275 | 0.580849 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,752 | serverbase.py | hkgdifyu_pFedPT/system/flcore/servers/serverbase.py | import torch
import os
import numpy as np
import h5py
import copy
import time
import random
from utils.data_utils import read_client_data
class Server(object):
def __init__(self, args, times):
# Set up the main attributes
self.device = args.device
self.dataset = args.dataset
self.global_rounds = args.global_rounds
self.local_steps = args.local_steps
self.batch_size = args.batch_size
self.learning_rate = args.local_learning_rate
self.global_model = copy.deepcopy(args.model)
self.num_clients = args.num_clients
self.join_ratio = args.join_ratio
self.join_clients = int(self.num_clients * self.join_ratio)
self.algorithm = args.algorithm
self.time_select = args.time_select
self.goal = args.goal
self.time_threthold = args.time_threthold
self.save_folder_name = args.save_folder_name
self.num_prompt = args.num_prompt
self.args = args
self.plocal_steps = args.plocal_steps
self.top_cnt = 100
self.clients = []
self.selected_clients = []
self.train_slow_clients = []
self.send_slow_clients = []
self.uploaded_weights = []
self.uploaded_ids = []
self.uploaded_models = []
self.rs_test_acc = []
self.rs_test_acc_std = []
self.rs_test_auc = []
self.rs_train_loss = []
self.times = times
self.eval_gap = args.eval_gap
self.client_drop_rate = args.client_drop_rate
self.train_slow_rate = args.train_slow_rate
self.send_slow_rate = args.send_slow_rate
def set_clients(self, args, clientObj):
for i, train_slow, send_slow in zip(range(self.num_clients), self.train_slow_clients, self.send_slow_clients):
train_data = read_client_data(self.dataset, i, args,is_train=True)
test_data = read_client_data(self.dataset, i, args,is_train=False)
client = clientObj(args,
id=i,
train_samples=len(train_data),
test_samples=len(test_data),
train_slow=train_slow,
send_slow=send_slow)
self.clients.append(client)
# random select slow clients
def select_slow_clients(self, slow_rate):
slow_clients = [False for i in range(self.num_clients)]
idx = [i for i in range(self.num_clients)]
idx_ = np.random.choice(idx, int(slow_rate * self.num_clients))
for i in idx_:
slow_clients[i] = True
return slow_clients
def set_slow_clients(self):
self.train_slow_clients = self.select_slow_clients(
self.train_slow_rate)
self.send_slow_clients = self.select_slow_clients(
self.send_slow_rate)
def select_clients(self):
selected_clients = list(np.random.choice(self.clients, self.join_clients, replace=False))
return selected_clients
def send_models(self):
assert (len(self.clients) > 0)
for client in self.clients:
client.set_parameters(self.global_model)
def receive_models(self):
assert (len(self.selected_clients) > 0)
self.uploaded_weights = []
tot_samples = 0
self.uploaded_ids = []
self.uploaded_models = []
for client in self.selected_clients:
self.uploaded_weights.append(client.train_samples)
tot_samples += client.train_samples
self.uploaded_ids.append(client.id)
self.uploaded_models.append(client.model)
for i, w in enumerate(self.uploaded_weights):
self.uploaded_weights[i] = w / tot_samples
def aggregate_parameters(self):
assert (len(self.uploaded_models) > 0)
self.global_model = copy.deepcopy(self.uploaded_models[0])
for param in self.global_model.parameters():
param.data.zero_()
for w, client_model in zip(self.uploaded_weights, self.uploaded_models):
self.add_parameters(w, client_model)
def add_parameters(self, w, client_model):
for server_param, client_param in zip(self.global_model.parameters(), client_model.parameters()):
server_param.data += client_param.data.clone() * w
def save_global_model(self):
model_path = os.path.join("models", self.dataset, self.args.arv1+"*"+self.args.arv2+"*"+self.args.arv3+"*"+self.args.arv4+"*"+self.args.arv5+"*"+self.args.arv6)
if not os.path.exists(model_path):
os.makedirs(model_path)
model_path = os.path.join(model_path, self.algorithm + "_server"+ "_" + str(self.num_prompt) + "_" + str(self.join_ratio) + "_" + str(self.num_clients)+ "_" + str(self.plocal_steps) + "_" + str(self.global_rounds) + ".pt")
torch.save(self.global_model, model_path)
def load_model(self):
model_path = os.path.join("models", self.dataset, self.args.arv1+"*"+self.args.arv2+"*"+self.args.arv3+"*"+self.args.arv4+"*"+self.args.arv5+"*"+self.args.arv6)
model_path = os.path.join(model_path, self.algorithm + "_server" + "_" + str(self.num_prompt) + "_" + str(self.join_ratio) + "_" + str(self.num_clients)+ "_" + str(self.plocal_steps) + "_" + str(self.global_rounds) +".pt")
assert (os.path.exists(model_path))
self.global_model = torch.load(model_path)
def model_exists(self):
model_path = os.path.join("models", self.dataset, self.args.arv1+"*"+self.args.arv2+"*"+self.args.arv3+"*"+self.args.arv4+"*"+self.args.arv5+"*"+self.args.arv6)
model_path = os.path.join(model_path, self.algorithm + "_" + str(self.num_prompt) + "_" + str(self.join_ratio) + "_" + str(self.num_clients)+ "_" + str(self.plocal_steps) + "_" + str(self.global_rounds)+".pt")
return os.path.exists(model_path)
def save_results(self):
algo = self.dataset + "_" + self.algorithm
result_path = "../results/"+ self.args.arv1+"*"+self.args.arv2+"*"+self.args.arv3+"*"+self.args.arv4+"*"+self.args.arv5+"*"+self.args.arv6 +"/"
if not os.path.exists(result_path):
os.makedirs(result_path)
if (len(self.rs_test_acc)):
algo = algo + "_" + self.goal + "_" + str(self.times)+ "_" + str(self.num_prompt) + "_" + str(self.join_ratio) + "_" + str(self.num_clients)+ "_" + str(self.plocal_steps) + "_" + str(self.global_rounds)
file_path = result_path + "{}.h5".format(algo)
print("File path: " + file_path)
with h5py.File(file_path, 'w') as hf:
hf.create_dataset('rs_test_acc', data=self.rs_test_acc)
hf.create_dataset('rs_test_acc_std', data=self.rs_test_acc_std)
hf.create_dataset('rs_test_auc', data=self.rs_test_auc)
hf.create_dataset('rs_train_loss', data=self.rs_train_loss)
def save_item(self, item, item_name):
if not os.path.exists(self.save_folder_name):
os.makedirs(self.save_folder_name)
torch.save(item, os.path.join(self.save_folder_name, "server_" + item_name + "_" + str(self.num_prompt) + "_" + str(self.join_ratio) + "_" + str(self.num_clients)+ "_" + str(self.plocal_steps) + "_" + str(self.global_rounds) + ".pt"))
def load_item(self, item_name):
return torch.load(os.path.join(self.save_folder_name, "server_" + item_name + "_" + str(self.num_prompt) + "_" + str(self.join_ratio) + "_" + str(self.num_clients)+ "_" + str(self.plocal_steps) + "_" + str(self.global_rounds) + ".pt"))
def test_metrics(self):
num_samples = []
tot_correct = []
tot_auc = []
for c in self.clients:
ct, ns, auc = c.test_metrics()
tot_correct.append(ct*1.0)
tot_auc.append(auc*ns)
num_samples.append(ns)
ids = [c.id for c in self.clients]
return ids, num_samples, tot_correct, tot_auc
def test_metrics2(self):
num_samples = []
tot_correct = []
tot_auc = []
for c in self.selected_clients:
ct, ns, auc = c.test_metrics()
tot_correct.append(ct*1.0)
tot_auc.append(auc*ns)
num_samples.append(ns)
ids = [c.id for c in self.clients]
return ids, num_samples, tot_correct, tot_auc
def train_metrics(self):
num_samples = []
losses = []
for c in self.clients:
cl, ns = c.train_metrics()
num_samples.append(ns)
losses.append(cl*1.0)
ids = [c.id for c in self.clients]
return ids, num_samples, losses
# evaluate selected clients
def evaluate(self, acc=None, loss=None):
if acc == None:
stats = self.test_metrics()
else:
stats = self.test_metrics()
stats_train = self.train_metrics()
test_acc = sum(stats[2])*1.0 / sum(stats[1])
test_auc = sum(stats[3])*1.0 / sum(stats[1])
train_loss = sum(stats_train[2])*1.0 / sum(stats_train[1])
accs = [a / n for a, n in zip(stats[2], stats[1])]
aucs = [a / n for a, n in zip(stats[3], stats[1])]
if acc == None:
self.rs_test_acc.append(test_acc)
else:
acc.append(test_acc)
self.rs_test_auc.append(test_auc)
self.rs_test_acc_std.append(np.std(accs))
if loss == None:
self.rs_train_loss.append(train_loss)
else:
loss.append(train_loss)
print("Averaged Train Loss: {:.4f}".format(train_loss))
print("Averaged Test Accurancy: {:.4f}".format(test_acc))
print("Averaged Test AUC: {:.4f}".format(test_auc))
# self.print_(test_acc, train_acc, train_loss)
print("Std Test Accurancy: {:.4f}".format(np.std(accs)))
print("Std Test AUC: {:.4f}".format(np.std(aucs)))
def print_(self, test_acc, test_auc, train_loss):
print("Average Test Accurancy: {:.4f}".format(test_acc))
print("Average Test AUC: {:.4f}".format(test_auc))
print("Average Train Loss: {:.4f}".format(train_loss))
def check_done(self, acc_lss, top_cnt=None, div_value=None):
for acc_ls in acc_lss:
if top_cnt != None and div_value != None:
find_top = len(acc_ls) - torch.topk(torch.tensor(acc_ls), 1).indices[0] > top_cnt
find_div = len(acc_ls) > 1 and np.std(acc_ls[-top_cnt:]) < div_value
if find_top and find_div:
pass
else:
return False
elif top_cnt != None:
find_top = len(acc_ls) - torch.topk(torch.tensor(acc_ls), 1).indices[0] > top_cnt
if find_top:
pass
else:
return False
elif div_value != None:
find_div = len(acc_ls) > 1 and np.std(acc_ls[-top_cnt:]) < div_value
if find_div:
pass
else:
return False
else:
raise NotImplementedError
return True
| 11,178 | Python | .py | 222 | 39.572072 | 243 | 0.583571 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,753 | serveravg.py | hkgdifyu_pFedPT/system/flcore/servers/serveravg.py | import time
import torch
from flcore.clients.clientavg import clientAVG
from flcore.servers.serverbase import Server
from threading import Thread
class FedAvg(Server):
def __init__(self, args, times):
super().__init__(args, times)
# select slow clients
self.set_slow_clients()
self.set_clients(args, clientAVG)
print(f"\nJoin ratio / total clients: {self.join_ratio} / {self.num_clients}")
print("Finished creating server and clients.")
# self.load_model()
self.Budget = []
def train(self):
local_acc = []
for i in range(self.global_rounds+1):
s_t = time.time()
self.selected_clients = self.select_clients()
self.send_models()
if i%self.eval_gap == 0:
print(f"\n-------------Round number: {i}-------------")
print("\nEvaluate global model")
self.evaluate()
for client in self.selected_clients:
client.train()
# threads = [Thread(target=client.train)
# for client in self.selected_clients]
# [t.start() for t in threads]
# [t.join() for t in threads]
if i%self.eval_gap == 0:
print("\nEvaluate local model")
self.evaluate(acc=local_acc)
self.receive_models()
self.aggregate_parameters()
self.Budget.append(time.time() - s_t)
print('-'*25, 'time cost', '-'*25, self.Budget[-1])
# i= i+1
#
# s_t = time.time()
# self.selected_clients = self.clients
# self.send_models()
#
# if i % self.eval_gap == 0:
# print(f"\n-------------Round number: {i}-------------")
# print("\nEvaluate global model")
# self.evaluate()
#
# for client in self.selected_clients:
# client.local_steps = 50
# client.train()
#
# # threads = [Thread(target=client.train)
# # for client in self.selected_clients]
# # [t.start() for t in threads]
# # [t.join() for t in threads]
# if i % self.eval_gap == 0:
# print("\nEvaluate local model")
# self.evaluate(acc=local_acc)
# self.receive_models()
# self.aggregate_parameters()
#
# self.Budget.append(time.time() - s_t)
# print('-' * 25, 'time cost', '-' * 25, self.Budget[-1])
print("\nBest global accuracy.")
# self.print_(max(self.rs_test_acc), max(
# self.rs_train_acc), min(self.rs_train_loss))
print(max(self.rs_test_acc))
print("\nBest local accuracy.")
print(max(local_acc))
print("\nAverage time cost per round.")
print(sum(self.Budget[1:])/len(self.Budget[1:]))
self.save_results()
self.save_global_model()
| 2,949 | Python | .py | 75 | 29.466667 | 86 | 0.528691 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,754 | serverrep.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverrep.cpython-37.pyc | B
·:cc ã @ sH d dl mZ d dlmZ d dlmZ d dlZd dlZG dd„ deƒZdS )é )Ú clientRep)ÚServer)ÚThreadNc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedRepc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverrep.pyr s zFedRep.__init__c C s
x®t | jd ƒD ]œ}t ¡ }| ¡ | _| ¡ || j dkr\td|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ qdW |
¡ | ¡ | j
t ¡ | ¡ tddd| j d ƒ qW td ƒ tt| jƒƒ td
ƒ tt| j dd … ƒt| j dd … ƒ ƒ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersr
ÚappendÚmaxÚ rs_test_accÚsumÚlenÚ save_resultsÚsave_global_model)r ÚiÚs_tÚclientr r r r s(
(z FedRep.trainc C sŒ t | jƒdkst‚d}x| jD ]}||j7 }q W g | _g | _g | _xD| jD ]:}| j |j| ¡ | j |j¡ | j t
|j j ¡¡ qJW d S )Nr )
r% r ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr! ÚidÚcopyÚdeepcopyÚmodelÚbase)r Zactive_train_samplesr* r r r r : s zFedRep.receive_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r )r r r s #r ) Z system.flcore.clients.clientrepr Ú system.flcore.servers.serverbaser Ú threadingr r r1 r r r r r Ú<module> s
| 2,146 | Python | .py | 16 | 132.6875 | 338 | 0.47771 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,755 | servermtl.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/servermtl.cpython-39.pyc | a
f¾`c ã @ s@ d dl Z d dlmZ d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú clientMTL)ÚServer)ÚThreadc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚFedMTLc sÈ t ƒ ||¡ t| | j¡ƒ| _tj| j| jf|j d�| _
|j | _ t | j| jf¡}t | jdf¡}|d| j | |j
¡ d }| |j ¡| _| ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )N©Údeviceé é z
Join clients / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚlenÚflattenÚ global_modelÚdimÚtorchÚzerosÚ join_clientsr ÚW_globÚonesÚmmÚTÚtoÚomegaÚset_slow_clientsÚ set_clientsr ÚprintÚ num_clients)ÚselfÚargsÚtimesÚIÚir ©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/servermtl.pyr s zFedMTL.__init__c C s¬ t | jd ƒD ]r}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ t| jƒD ]"\}}| | j
| j |¡ | ¡ q\qtdƒ tt
| jƒƒ | ¡ | ¡ d S )Nr r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚaggregate_parametersÚeval_gapr ÚevaluateÚ enumerateZreceive_valuesr r ÚtrainÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r r! ÚidxÚclientr$ r$ r% r. s
z FedMTL.trainc s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r$ )r
)Ú.0Úkey©Ú
state_dictr$ r% Ú
<listcomp>< ó z"FedMTL.flatten.<locals>.<listcomp>)r8 Úkeysr Úcat)r Úmodelr; ÚWr$ r7 r% r
9 s zFedMTL.flattenc C sL t j| j| jf| jd�| _t| jƒD ]"\}}| |j ¡| jd d …|f< q$d S )Nr )
r r r r r r r- r) r
r= )r r3 r4 r$ r$ r% r* ? s zFedMTL.aggregate_parameters)Ú__name__Ú
__module__Ú __qualname__r r. r
r* Ú
__classcell__r$ r$ r" r% r s r )r Zflcore.clients.clientmtlr Úflcore.servers.serverbaser Ú threadingr r r$ r$ r$ r% Ú<module> s | 2,406 | Python | .py | 13 | 183.846154 | 602 | 0.442356 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,756 | serverdyn.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverdyn.cpython-38.pyc | U
Mrgc ã @ sP d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZ dS )é N)Ú clientDyn)ÚServer)ÚThreadc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Z‡ ZS ) ÚFedDync s€ t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _|j | _ t
|j ¡| _
| j
¡ D ]}t |j¡|_qhd S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚalphaÚcopyÚdeepcopyÚmodelÚ server_stateÚ
parametersÚtorchÚ
zeros_likeÚdata)ÚselfÚargsÚtimesÚparam©Ú __class__© õD D:\京东\promot\cifar\cifar\tiny\system\flcore\servers\serverdyn.pyr
s zFedDyn.__init__c C sh g }d| _ d}t| jd ƒD ]Ü}t ¡ }| ¡ | _| ¡ || j dkrhtd|› d�ƒ tdƒ | ¡ | jD ] }|
¡ qn|| j dkržtdƒ | j |d� | ¡ | ¡ |
¡ | j t ¡ | ¡ td | jd
ƒ | j| jg| jd �| _ |d7 }q td ƒ tt| jƒƒ td
ƒ tt|ƒƒ tdƒ tt| jdd … ƒt| jdd … ƒ ƒ | ¡ | ¡ d S )NFr é z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cntz
Best global accuracy.z
Best local accuracy.z
Averaged time per iteration.)ÚdoneÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚupdate_server_stateÚaggregate_parametersr
ÚappendÚ
check_doneÚ rs_test_accr# ÚmaxÚsumÚlenÚ save_resultsÚsave_global_model)r Z local_accÚiÚs_tÚclientr r r r- s>
(z FedDyn.trainc C s< t | j ¡ | ¡ ƒD ]"\}}| j|j ¡ | j 7 _qd S )N)ÚzipÚ global_modelr r ÚcloneÚ join_clients)r Ú client_modelÚ server_paramÚ client_paramr r r Úadd_parametersO s zFedDyn.add_parametersc C s” t | jƒdkst‚t | jd ¡| _| j ¡ D ]}t |j ¡|_ q.| jD ]}|
|¡ qHt | j ¡ | j ¡ ƒD ] \}}| j d| j
| 8 _ qnd S )Nr r )r6 Úuploaded_modelsÚAssertionErrorr r r= r r r r rC r< r r )r r r@ rA Ú state_paramr r r r0 S s
zFedDyn.aggregate_parametersc C s¾ t | jƒdkst‚t | jd ¡}| ¡ D ]}t |j¡|_q*| jD ]B}t | j
¡ | ¡ | ¡ ƒD ]"\}}}| j|| | j 7 _qbqDt | j ¡ | ¡ ƒD ] \}}| j| j
| 8 _qœd S )Nr )r6 rD rE r r r r r r r< r= r r r )r Z model_deltar r@ rA rB Z delta_paramrF r r r r/ ` s
$ zFedDyn.update_server_state) Ú__name__Ú
__module__Ú __qualname__r r- rC r0 r/ Ú
__classcell__r r r r r s
1
r )
r r Zflcore.clients.clientdynr Úflcore.servers.serverbaser Ú threadingr r' r r r r r Ú<module> s | 3,276 | Python | .py | 30 | 107.9 | 399 | 0.434247 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,757 | serverperavg.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverperavg.cpython-38.pyc | U
”jfc‚ ã @ sH d dl Z d dlZd dlmZ d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú clientPerAvg)ÚServer)ÚThreadc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚPerAvgc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õN D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\servers\serverperavg.pyr s
zPerAvg.__init__c C sª t | jd ƒD ]p}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ]}| ¡ | ¡ qX| ¡ |
¡ qtdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z+
Evaluate global model with one step updatez
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
Úevaluate_one_stepÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s
z PerAvg.trainc C s’ g }| j D ] }| t |j¡¡ | ¡ q
| ¡ }t| j ƒD ]\}}| || |j¡ q<t |d ƒd t |d ƒ }| j
|¡ t d |¡ƒ d S )Né g ğ?r z Average Test Accurancy: {:.4f})
ÚclientsÚappendÚcopyÚdeepcopyÚmodelZtrain_one_stepÚ test_metricsÚ enumerateÚ clone_modelÚsumr r
Úformat)r
Z models_tempÚcÚstatsr# Útest_accr r r r 4 s
zPerAvg.evaluate_one_step)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r r r r s
!r ) r( ÚtorchZflcore.clients.clientperavgr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s
| 2,024 | Python | .py | 22 | 90.727273 | 347 | 0.482776 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,758 | serverpFedMe.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverpFedMe.cpython-39.pyc | a
f¾`cE ã @ sP d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ G dd„ deƒZ dS )é N)Ú clientpFedMe)ÚServer)ÚThreadc sL e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zd d „ Zd
d„ Z ‡ Z
S )ÚpFedMec s` t ƒ ||¡ | ¡ | |t¡ |j| _g | _g | _g | _t d| j
› d| j › �ƒ t dƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚbetaÚrs_train_acc_perÚrs_train_loss_perÚrs_test_acc_perÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© úu/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverpFedMe.pyr
s zpFedMe.__init__c C sÀ t | jd ƒD ]†}| ¡ | _| ¡ | jD ] }| ¡ q*|| j dkrftd|› d�ƒ tdƒ | ¡ t
t | j
¡ ƒ¡| _| ¡ | ¡ | ¡ qtdƒ tt| jƒƒ | ¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate personalized modelz
Best personalized results.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚtrainÚeval_gapr Úevaluate_personalized_modelÚcopyÚdeepcopyÚlistÚ global_modelÚ
parametersÚprevious_global_modelÚreceive_modelsÚaggregate_parametersÚbeta_aggregate_parametersÚmaxr
Ú save_resultsÚsave_global_model)r ÚiÚclientr r r r s"
z pFedMe.trainc C s> t | j| j ¡ ƒD ]&\}}d| j |j | j|j |_qd S )Nr )Úzipr& r$ r% r
Údata)r Z pre_paramÚparamr r r r) D s z pFedMe.beta_aggregate_parametersc C sR g }g }| j D ](}| ¡ \}}| |d ¡ | |¡ qdd„ | j D ƒ}|||fS )Nç ð?c S s g | ]
}|j ‘qS r ©Úid©Ú.0Úcr r r Ú
<listcomp>P ó z4pFedMe.test_metrics_personalized.<locals>.<listcomp>)ÚclientsÚtest_metrics_personalizedÚappend)r Ú num_samplesÚ tot_correctr7 ÚctÚnsÚidsr r r r; I s
z pFedMe.test_metrics_personalizedc C sh g }g }g }| j D ]8}| ¡ \}}}| |d ¡ | |¡ | |d ¡ qdd„ | j D ƒ}||||fS )Nr2 c S s g | ]
}|j ‘qS r r3 r5 r r r r8 ^ r9 z5pFedMe.train_metrics_personalized.<locals>.<listcomp>)r: Útrain_metrics_personalizedr< ) r r= r> Úlossesr7 r? Úclr@ rA r r r rB T s
z!pFedMe.train_metrics_personalizedc C sB | ¡ }t|d ƒd t|d ƒ }| j |¡ td |¡ƒ d S )Né r2 r z+Average Personalized Test Accurancy: {:.4f})r; Úsumr
r< r Úformat)r ÚstatsÚtest_accr r r r b s z"pFedMe.evaluate_personalized_modelc C sº | j d | j }d}tj |¡s*t |¡ t| jƒr¶|d | j d t | j
ƒ }t |d
|¡ d¡�@}|jd| jd� |jd| jd� |jd| jd� W d ƒ n1 s¬0 Y d S ) NÚ_z ../results/z{}.h5ÚwÚ rs_test_acc)r0 Z rs_train_accÚ
rs_train_loss)ÚdatasetÚ algorithmÚosÚpathÚexistsÚmakedirsÚlenr
ÚgoalÚstrr Úh5pyÚFilerG Úcreate_datasetr r )r ÚalgoÚ result_pathZalgo2Úhfr r r r+ q s
zpFedMe.save_results) Ú__name__Ú
__module__Ú __qualname__r r r) r; rB r r+ Ú
__classcell__r r r r r s + r )
rP r! rW Zflcore.clients.clientpFedMer Zflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 3,828 | Python | .py | 28 | 135.428571 | 434 | 0.464596 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,759 | serverphp.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverphp.cpython-39.pyc | a
f¾`c” ã @ sH d dl mZ d dlmZ d dlmZ d dlZd dlZG dd„ deƒZdS )é )Ú clientPHP)ÚServer)ÚThreadNc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedPHPc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverphp.pyr s zFedPHP.__init__c C s¤ t | jd ƒD ]j}| ¡ | _| |¡ || j dkrTtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qZ| ¡ |
¡ qtdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r ÚiÚclientr r r r s
z FedPHP.trainc C s0 t | jƒdksJ ‚| jD ]}| | j|¡ qd S )Nr )Úlenr Úset_parametersÚ global_model)r ÚRr% r r r r 5 s
zFedPHP.send_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r r r r s r ) Zflcore.clients.clientphpr Úflcore.servers.serverbaser Ú threadingr ÚtimeÚcopyr r r r r Ú<module> s
| 1,758 | Python | .py | 17 | 102.176471 | 371 | 0.487371 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,760 | serveravg.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serveravg.cpython-37.pyc | B
¿:ccç ã @ sH d dl Z d dlZd dlmZ d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú clientAVG)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚFedAvgc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Zset_slow_clientsZ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serveravg.pyr s zFedAvg.__init__c C s
x®t | jd ƒD ]œ}t ¡ }| ¡ | _| ¡ || j dkr\td|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ qdW |
¡ | ¡ | j
t ¡ | ¡ tddd| j d ƒ qW td ƒ tt| jƒƒ td
ƒ tt| j dd … ƒt| j dd … ƒ ƒ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)ÚrangeÚ
global_roundsÚtimeZselect_clientsZselected_clientsZ send_modelsÚeval_gapr ZevaluateÚtrainZreceive_modelsZaggregate_parametersr ÚappendÚmaxZ rs_test_accÚsumÚlenZ save_resultsZsave_global_model)r ÚiZs_tÚclientr r r r s(
(z FedAvg.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r )r r r s r ) r ÚtorchZ system.flcore.clients.clientavgr Z system.flcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s
| 1,721 | Python | .py | 14 | 121.571429 | 330 | 0.485948 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,761 | servermtlpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/servermtlpt.cpython-38.pyc | U
Õ şc² ã @ sh d dl Z d dlmZ d dlmZ d dlmZ d dlZd dlZd dl Z d dl Z d dl
Z G dd„ deƒZ dS )é N)Ú clientMTLPT)ÚServer)ÚThreadc s^ e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zdd d
„Zdd„ Z dd„ Z
dd„ Z ‡ Z S )ÚFedMTLPTc sÚ t ƒ ||¡ || _t| | j¡ƒ| _tj| j| j f|j
d�| _ |j
| _
t | j | j f¡}t | j df¡}|d| j |
|j¡ d }| |j
¡| _g | _g | _| ¡ | |t¡ td| j › d| j› �ƒ tdƒ d S )N©Údeviceé é z
Join clients / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚargsÚlenÚflattenÚ global_modelÚdimÚtorchÚzerosÚ join_clientsr ÚW_globÚonesÚmmÚTÚtoÚomegaÚclients_divergeÚdiff_proÚset_slow_clientsÚ set_clientsr ÚprintÚ num_clients)Úselfr ÚtimesÚIÚir ©Ú __class__© õc D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\servermtlpt.pyr s zFedMTLPT.__init__c C s¢ g }t | jd ƒD �]F}| ¡ | _| ¡ || j dkrXtd|› d�ƒ tdƒ | ¡ d}t| jƒD ].\}}| | j
| j |¡ | ¡ }||
¡ }qftd |¡ƒ | j |¡ d}t| jd jj ¡ | jd jj ¡ ƒD ]:\}} || }
t |
dk|
t |
¡|
¡}
|t |
¡ }qÚtd |
¡ ¡ƒ | j |
¡ ¡ || j dkrtdƒ | j|d � qtd
ƒ tt| j ƒƒ td ƒ tt|ƒƒ | ¡ | ¡ | ¡ d S ) Nr r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚaggregate_parametersÚeval_gapr ÚevaluateÚ enumerateÚreceive_valuesr r ÚtrainÚitemÚformatr ÚappendÚzipÚclientsÚmodelÚ generatorÚ
parametersr ÚwhereÚ
zeros_likeÚsumr ÚmaxÚ rs_test_accÚ save_resultsÚsave_global_modelÚsave_client_model) r Ú local_accr# Ú
temp_diff_proÚidxÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r& r& r' r2 sD
ÿ zFedMTLPT.trainc C s‚ t | jƒdkst‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]8}| j |j| ¡ | j |j¡ | j t
|j ¡¡ qDd S )Nr ) r
r, ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr5 ÚidÚcopyÚdeepcopyr8 )r Úactive_train_samplesrF r& r& r' Úreceive_modelsM s
zFedMTLPT.receive_modelsc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsrF Ú*Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsr0 r7 Ú algorithmÚstrÚ
num_promptÚ
join_ratior Ú plocal_stepsr* r Úsaver8 )r Ú
model_pathÚc_idxÚcÚmodel_path_saver& r& r' rB [ s T
pzFedMTLPT.save_client_modelc C s€ | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r||d | j d t| jƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd � |jd
| j d � |jd | j d � |jd | j d � |jd
| j d � |jd| j d � W 5 Q R X d S )NrX z ../results/rV ú/z{}.h5z File path: Úwr? )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )!r\ re r r] r^ r_ r` ra rb rY rZ rc rd r
r? Úgoalrf r! rg rh r ri r* r4 r Úh5pyÚFileÚcreate_datasetrr rs rt r r )r ÚalgoÚ result_pathÚ file_pathÚhfr& r& r' r@ c s L
l zFedMTLPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Nr ç ğ?r é é c S s g | ]\}}|| ‘qS r& r& ©Ú.0ÚaÚnr& r& r' Ú
<listcomp> s z%FedMTLPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r& r& r€ r& r& r' r„ € s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr= r6 r? r5 rs rr ÚnpÚstdrt r r4 ) r r( ÚlossÚstatsÚ stats_trainÚtest_accÚ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr& r& r' r/ v s,
zFedMTLPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nr} c S s g | ]
}|j ‘qS r& )rP )r� rm r& r& r' r„ ¢ s z)FedMTLPT.test_metrics.<locals>.<listcomp>)r7 r… r5 ) r Ú num_samplesÚ tot_correctÚ tot_correct2Útot_aucrm ÚctÚct2ÚnsÚaucÚidsr& r& r' r… • s
zFedMTLPT.test_metricsc s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r& )r )r� Úkey©Ú
state_dictr& r' r„ © s z$FedMTLPT.flatten.<locals>.<listcomp>)r� Úkeysr Úcat)r r8 r� ÚWr& rœ r' r ¦ s zFedMTLPT.flattenc C sL t j| j| jf| jd�| _t| jƒD ]"\}}| |j ¡| jd d …|f< q$d S )Nr )
r r r r r r r0 r, r r8 )r rE rF r& r& r' r- ¬ s z FedMTLPT.aggregate_parameters)NN)
Ú__name__Ú
__module__Ú __qualname__r r2 rT rB r@ r/ r… r r- Ú
__classcell__r& r& r$ r' r s -
r )
r Zflcore.clients.clientmtlptr Úflcore.servers.serverbaser Ú threadingr rv rQ rY Únumpyr‡ r r& r& r& r' Ú<module> s | 6,744 | Python | .py | 57 | 117.122807 | 640 | 0.419258 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,762 | serverperpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverperpt.cpython-38.pyc | U
Õ şcG ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z G dd„ deƒZ dS )é )Ú clientPerPT)ÚServer)ÚThreadNc sN e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zdd d
„Zdd„ Z ‡ Z
S )ÚFedPerPTc sR t ƒ ||¡ | ¡ | |t¡ g | _g | _td| j› d| j › �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)
ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr Úclients_divergeÚdiff_proÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õc D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\serverperpt.pyr
s zFedPerPT.__init__c
C sš g }t | jd ƒD �]>}| ¡ | _| ¡ || j dkrXtd|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }|| ¡ }qbtd
|¡ƒ | j |¡ d}t
| jd jj ¡ | jd jj ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qÀtd
| ¡ ¡ƒ | j | ¡ ¡ || j dk�rBtdƒ | j|d � | ¡ | ¡ qtd
ƒ tt| jƒƒ td ƒ tt|ƒƒ | ¡ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsÚmodelÚ generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr
Úreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_modelÚsave_client_model)
r Ú local_accÚiÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r sF
ÿ
zFedPerPT.trainc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsr6 Ú*Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsÚ enumerater$ Ú algorithmÚstrÚ
num_promptr
r Ú plocal_stepsr r( Úsaver% )r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r2 E s T
pzFedPerPT.save_client_modelc C s� t | jƒdkst‚g | _d}g | _g | _| jD ]8}| j |j¡ ||j7 }| j |j¡ | j |j ¡ q.t
| jƒD ]\}}|| | j|< qrd S )Nr ) Úlenr ÚAssertionErrorÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr" Ú
train_samplesÚidr% rK )r Ú tot_samplesr6 r4 Úwr r r r, M s
zFedPerPT.receive_modelsc C s | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r |d | j d t| jƒ }|d |¡ }td| ƒ t |d¡�V}|jd| jd � |jd
| jd � |jd | jd � |jd | jd � |jd
| jd � W 5 Q R X d S )Nr> z ../results/r< ú/z{}.h5z File path: r] r/ )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr )rB rL r rC rD rE rF rG rH r? r@ rI rJ rU r/ ÚgoalrM r r! r Úh5pyÚFileÚcreate_datasetr` ra rb r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r0 \ s L
zFedPerPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Né ç ğ?r é é c S s g | ]\}}|| ‘qS r r ©Ú.0ÚaÚnr r r Ú
<listcomp>v s z%FedPerPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r r ro r r r rs w s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr+ r# r/ r" ra r` ÚnpÚstdrb r r! ) r r ÚlossÚstatsÚ stats_trainÚtest_accÚ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr r r r m s,
zFedPerPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nrl c S s g | ]
}|j ‘qS r )r[ )rp rS r r r rs š s z)FedPerPT.test_metrics.<locals>.<listcomp>)r$ rt r" ) r Ú num_samplesÚ tot_correctÚ tot_correct2Útot_aucrS ÚctÚct2ÚnsÚaucÚidsr r r rt ‹ s
zFedPerPT.test_metrics)NN) Ú__name__Ú
__module__Ú __qualname__r r r2 r, r0 r rt Ú
__classcell__r r r r r s -
r )
Zflcore.clients.clientperptr Úflcore.servers.serverbaser Ú threadingr rd Úcopyr? r( Únumpyrv r r r r r Ú<module> s | 5,687 | Python | .py | 52 | 108.153846 | 496 | 0.432044 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,763 | serverdynpt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverdynpt.cpython-37.pyc | B
‰½ccÉ ã @ sh d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlZd dl Z d dl Z d dl
Z
G dd„ deƒZ dS )é N)Ú clientDynPT)ÚServer)ÚThreadc sL e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zd d „ Zd
d„ Z ‡ Z
S )ÚFedDynPTc s� t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _g | _ |j
| _
g | _ t
|j¡| _x | j ¡ D ]}t |j¡|_qvW d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚdiff_proÚalphaÚclients_divergeÚcopyÚdeepcopyÚmodelÚ server_stateÚ
parametersÚtorchÚ
zeros_likeÚdata)ÚselfÚargsÚtimesÚparam)Ú __class__© úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverdynpt.pyr s zFedDynPT.__init__c C s, g }d| _ d}�x¬t| jd ƒD �]˜}t ¡ }| ¡ | _| ¡ || j dkrntd|› d�ƒ tdƒ | ¡ d}x"| jD ]}|
¡ }|| ¡ }qzW td |¡ƒ | j
|¡ d}xdt| jd jj ¡ | jd jj ¡ ƒD ]:\}} || }
t |
dk|
t |
¡|
¡}
|t |
¡ }qÜW td | ¡ ¡ƒ | j | ¡ ¡ || j dk�r`td ƒ | j |d
� | ¡ | ¡ | ¡ | j t ¡ | ¡ td | j d ƒ | j | j g| j d
�| _ |d7 }q W tdƒ tt | j ƒƒ tdƒ tt |ƒƒ tdƒ tt| j dd … ƒt!| j dd … ƒ ƒ | "¡ | #¡ d S )NFr é z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cntz
Best global accuracy.z
Best local accuracy.z
Averaged time per iteration.)$ÚdoneÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsr Ú generatorr r Úwherer Úsumr Úreceive_modelsÚupdate_server_stateÚaggregate_parametersr
Ú
check_doneÚ rs_test_accr$ ÚmaxÚlenÚ save_resultsÚsave_global_model) r Ú local_accÚiÚs_tÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r. sT
0 (zFedDynPT.trainc C s@ x:t | j ¡ | ¡ ƒD ]"\}}| j|j ¡ | j 7 _qW d S )N)r2 Ú global_modelr r ÚcloneÚ join_clients)r Ú client_modelÚ server_paramÚ client_paramr r r Úadd_parameters\ s zFedDynPT.add_parametersc C s t | jƒdkst‚t | jd ¡| _x | j ¡ D ]}t |j ¡|_ q0W x| jD ]}|
|¡ qNW x:t | j ¡ | j ¡ ƒD ] \}}| j d| j
| 8 _ qxW d S )Nr r )r= Úuploaded_modelsÚAssertionErrorr r rI r r r r rO r2 r r )r r rL rM Ú state_paramr r r r9 ` s z FedDynPT.aggregate_parametersc C sÎ t | jƒdkst‚t | jd ¡}x | ¡ D ]}t |j¡|_q,W xP| jD ]F}x@t | j
¡ | ¡ | ¡ ƒD ]"\}}}| j|| | j 7 _qjW qJW x4t | j ¡ | ¡ ƒD ] \}}| j| j
| 8 _qªW d S )Nr )r= rP rQ r r r r r r r2 rI r r r )r Ú model_deltar rL rM rN Ú delta_paramrR r r r r8 m s z FedDynPT.update_server_statec C sŠ t | jƒdkst‚d}x| jD ]}||j7 }q W g | _g | _g | _xB| jD ]8}| j |j| ¡ | j |j¡ | j t
|j ¡¡ qJW d S )Nr ) r= r* rQ Ú
train_samplesÚuploaded_weightsÚ uploaded_idsrP r1 Úidr r r )r Úactive_train_samplesrD r r r r7 { s zFedDynPT.receive_modelsc C sÖ | j d | j }d}tj |¡s*t |¡ t| jƒrÒ|d | j d t | j
ƒ }|d |¡ }t d| ƒ t
|d¡�V}|jd| jd� |jd| jd� |jd | jd� |jd
| jd� |jd | jd� W d Q R X d S ) NÚ_z ../results/z{}.h5z File path: Úwr; )r Úrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr )ÚdatasetÚ algorithmÚosÚpathÚexistsÚmakedirsr= r; ÚgoalÚstrr r0 r
Úh5pyÚFileÚcreate_datasetr\ r] r^ r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r> ‰ s
zFedDynPT.save_results) Ú__name__Ú
__module__Ú __qualname__r r. rO r9 r8 r7 r> Ú
__classcell__r r )r r r s <
r ) r r Z!system.flcore.clients.clientdynptr Ú system.flcore.servers.serverbaser Ú threadingr r( rg ra r r r r r Ú<module> s | 4,852 | Python | .py | 39 | 123.179487 | 482 | 0.439551 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,764 | serverproxpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverproxpt.cpython-38.pyc | U
Õ şcœ ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z G dd„ deƒZ dS )é )Ú clientProxPT)ÚServer)ÚThreadNc sN e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zdd d
„Zdd„ Z ‡ Z
S )Ú FedProxPTc sf t ƒ ||¡ || _| ¡ | |t¡ g | _g | _t |j
¡| _ t d| j
› d| j› �ƒ t dƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr Úclients_divergeÚdiff_proÚcopyÚdeepcopyÚmodelÚ global_modelÚprintÚ
join_ratioÚ num_clients)Úselfr Útimes©Ú __class__© õd D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\serverproxpt.pyr s zFedProxPT.__init__c
C sš g }t | jd ƒD �]>}| ¡ | _| ¡ || j dkrXtd|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }|| ¡ }qbtd
|¡ƒ | j |¡ d}t
| jd jj ¡ | jd jj ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qÀtd
| ¡ ¡ƒ | j | ¡ ¡ || j dk�rBtdƒ | j|d � | ¡ | ¡ qtd
ƒ tt| jƒƒ td ƒ tt|ƒƒ | ¡ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsr Ú generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr Úreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_modelÚsave_client_model)
r Ú local_accÚiZ
temp_diff_proÚclientZtemp_diff_pro_clientZdiverge_clentsÚ new_paramÚ old_paramr r r r r# sF
ÿ
zFedProxPT.trainc C s‚ t | jƒdkst‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]8}| j |j| ¡ | j |j¡ | j t
|j ¡¡ qDd S )Nr ) Úlenr ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr& Úidr
r r )r Zactive_train_samplesr8 r r r r/ H s
zFedProxPT.receive_modelsc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsr8 Ú*Z_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsÚ enumerater( Ú algorithmÚstrÚ
num_promptr r Ú plocal_stepsr r+ Úsaver )r Ú
model_pathÚc_idxÚcZmodel_path_saver r r r5 V s T
pzFedProxPT.save_client_modelc C s€ | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r||d | j d t| jƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd � |jd
| j d � |jd | j d � |jd | j d � |jd
| j d � |jd| j d � W 5 Q R X d S )NrD z ../results/rC ú/z{}.h5z File path: Úwr2 )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )!rH rR r rI rJ rK rL rM rN rE rF rO rP r; r2 ÚgoalrS r rT r r rU r r% r Úh5pyÚFileÚcreate_datasetr] r^ r_ r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r3 ^ s L
l zFedProxPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Né ç ğ?r é é c S s g | ]\}}|| ‘qS r r ©Ú.0ÚaÚnr r r Ú
<listcomp>z s z&FedProxPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r r rl r r r rp { s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr. r' r2 r& r^ r] ÚnpÚstdr_ r r% ) r r ÚlossÚstatsÚ stats_trainÚtest_accZ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr r r r" q s,
zFedProxPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nri c S s g | ]
}|j ‘qS r )rA )rm rY r r r rp � s z*FedProxPT.test_metrics.<locals>.<listcomp>)r( rq r& ) r Ú num_samplesÚ tot_correctZ tot_correct2Útot_aucrY ÚctÚct2ÚnsÚaucÚidsr r r rq � s
zFedProxPT.test_metrics)NN) Ú__name__Ú
__module__Ú __qualname__r r# r/ r5 r3 r" rq Ú
__classcell__r r r r r
s .
r )
Zflcore.clients.clientproxptr Úflcore.servers.serverbaser Ú threadingr ra r
rE r+ Únumpyrs r r r r r Ú<module> s | 5,886 | Python | .py | 51 | 114.156863 | 497 | 0.43146 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,765 | serverbabu.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverbabu.cpython-39.pyc | a
f¾`c• ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú
clientBABU)ÚServer)ÚThreadc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedBABUc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverbabu.pyr s
zFedBABU.__init__c C sÆ t | jd ƒD ]h}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qX| ¡ |
¡ qtdƒ tt | j ƒƒ | j
D ] }| ¡ q”tdƒ | ¡ | ¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.z4
-------------Evaluate fine-tuned model-------------)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚclientsZ fine_tuneÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s&
z
FedBABU.trainc C s� t | jƒdksJ ‚g | _d}g | _g | _| jD ]:}| j |j¡ ||j7 }| j |j¡ | j |jj ¡ q.t
| jƒD ]\}}|| | j|< qtd S )Nr ) Úlenr Úuploaded_weightsÚ uploaded_idsÚuploaded_modelsÚappendÚ
train_samplesÚidÚmodelÚbaseÚ enumerate)r
Ú tot_samplesr% r$ Úwr r r r 7 s
zFedBABU.receive_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r r r r s
#r N)Zflcore.clients.clientbabur Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 2,038 | Python | .py | 22 | 91.454545 | 232 | 0.481904 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,766 | serverreppt.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverreppt.cpython-39.pyc | a
Òibck ã @ sX d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z G dd„ deƒZ
dS )é )Ú clientREPPT)ÚServer)ÚThreadNc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) Ú PFedRepPTc s\ t ƒ ||¡ | ¡ | |t¡ t |jj¡| _ t
d| j › d| j › �ƒ t
dƒ g | _
d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚcopyÚdeepcopyÚmodelÚbaseÚ global_modelÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverreppt.pyr s zPFedRepPT.__init__c C s
t | jd ƒD ]˜}t ¡ }| ¡ | _| ¡ || j dkrZtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ q`|
¡ | ¡ | j
t ¡ | ¡ tddd| j d ƒ qtd ƒ tt| jƒƒ td
ƒ tt| j dd … ƒt| j dd … ƒ ƒ | ¡ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersr ÚappendÚmaxÚ rs_test_accÚsumÚlenÚ save_resultsÚsave_global_modelÚsave_client_model)r ÚiÚs_tÚclientr r r r$ s*
(zPFedRepPT.trainc C s„ t | jƒdksJ ‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]:}| j |j| ¡ | j |j¡ | j t |j
j ¡¡ qDd S )Nr ) r+ r Ú
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr' Úidr
r r r
)r Úactive_train_samplesr1 r r r r% @ s
zPFedRepPT.receive_modelsc C sn t j d| jd¡}t j |¡s(t |¡ t| jƒD ]6\}}t j || jd t |ƒ d ¡}t
|j |¡ q2d S )NÚmodelsr1 Ú_serverz.pt)
ÚosÚpathÚjoinÚdatasetÚexistsÚmakedirsÚ enumerateÚclientsÚ algorithmÚstrÚtorchÚsaver )r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r. N s
zPFedRepPT.save_client_model)Ú__name__Ú
__module__Ú __qualname__r r$ r% r. Ú
__classcell__r r r r r
s &r ) Z!system.flcore.clients.clientrepptr Ú system.flcore.servers.serverbaser Ú threadingr r r
rD r: r r r r r Ú<module> s | 2,705 | Python | .py | 27 | 98.925926 | 326 | 0.483763 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,767 | serverlocal.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverlocal.cpython-38.pyc | U
ºĞıcc ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú clientAVG)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚLocalc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õY D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\servers\serverlocal.pyr s
zLocal.__init__c C sÎ g }t | jd ƒD ]|}| ¡ | _|| j dkrNtd|› d�ƒ tdƒ | ¡ | ¡ | _| jD ] }| ¡ q^|| j dkrtdƒ | j|d� qtdƒ tt| j ƒƒ td ƒ tt|ƒƒ |
¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚeval_gapr
ÚevaluateÚtrainÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
Ú local_accÚiÚclientr r r r s&
z Local.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s
r N)Úflcore.clients.clientavgr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,535 | Python | .py | 18 | 84.055556 | 318 | 0.480896 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,768 | serverfedpt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverfedpt.cpython-37.pyc | B
ÐecÓ ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z
G dd„ deƒZ dS )é )ÚclientT)ÚServer)ÚThreadNc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Z‡ ZS ) ÚFedPTc sn t ƒ ||¡ || _| ¡ | |t¡ t |jj ¡| _
g | _ g | _ t
d| j› d| j› �ƒ t
dƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr ÚcopyÚdeepcopyÚmodelÚbaseÚ global_modelÚdiff_proÚclients_divergeÚprintÚ
join_ratioÚ num_clientsÚBudget)Úselfr Útimes)Ú __class__© úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverfedpt.pyr s zFedPT.__init__c
C sÌ �xft | jd ƒD �]R}t ¡ }| ¡ | _| ¡ || j dkr`td|› d�ƒ tdƒ | ¡ d}x"| jD ]}| ¡ }||
¡ }qlW d}xdt | j d j
j ¡ | j d j
j ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }q´W td |¡ƒ td |
¡ ¡ƒ | j |¡ | j |
¡ ¡ | ¡ | ¡ | j t ¡ | ¡ tdd d| jd
ƒ qW td ƒ tt| j ƒƒ td ƒ tt| jdd … ƒt | jdd … ƒ ƒ | ¡ | ¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)!ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚzipÚclientsr
Ú generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumÚformatr Úappendr Úreceive_modelsÚaggregate_parametersr ÚmaxÚ rs_test_accÚlenÚ save_resultsÚsave_global_modelÚsave_client_model)
r ÚiÚs_tÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r% s@
0 (z FedPT.trainc C sŒ t | jƒdkst‚d}x| jD ]}||j7 }q W g | _g | _g | _xD| jD ]:}| j |j| ¡ | j |j¡ | j t
|j j ¡¡ qJW d S )Nr )
r5 r! ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr0 Úidr r r
r )r Úactive_train_samplesr< r r r r1 O s zFedPT.receive_modelsc C s t j d| jd¡}t j |¡s(t |¡ x”t| jƒD ]†\}}t j || jd t |ƒ d t | j
j ƒ d t | j
j ƒ d t | j
j
ƒ d t | j
jƒ d t | j
jƒ d ¡}t |j|¡ q4W d S )NÚmodelsr< Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetÚexistsÚmakedirsÚ enumerater( Ú algorithmÚstrr Ú
num_promptr r Ú plocal_stepsr r+ Úsaver
)r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r8 ] s
pzFedPT.save_client_modelc C s8 | j d | j }d}tj |¡s*t |¡ t| jƒ�r4|d | j d t | j
ƒ d t | j j ƒ d t | j j
ƒ d t | j jƒ d t | j jƒ d t | j jƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd� |jd| jd� |jd | jd� |jd
| jd� |jd | jd� |jd | jd� W d Q R X d S )
NrJ z ../results/z{}.h5z File path: Úwr4 )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )rN rR rK rL rO rP r5 r4 ÚgoalrS r r rT r r rU r r/ r Úh5pyÚFileÚcreate_datasetr] r^ r_ r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r6 e s
l zFedPT.save_results) Ú__name__Ú
__module__Ú __qualname__r r% r1 r8 r6 Ú
__classcell__r r )r r r
s
2r ) Z system.flcore.clients.clienttr Ú system.flcore.servers.serverbaser Ú threadingr r r+ rK ra r r r r r r Ú<module> s | 4,029 | Python | .py | 36 | 110.666667 | 397 | 0.457687 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,769 | serverfomo.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverfomo.cpython-39.pyc | a
f¾`ci ã @ s` d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlm Z d dl
m Z G dd„ de ƒZ dS )é N)Ú
clientFomo)ÚServer)ÚThreadc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚFedFomoc s€ t ƒ ||¡ | ¡ | |t¡ t tj| j| j d�¡| _
| j g| _ g | _
t|j| jƒ| _td| j› d| j› �ƒ tdƒ d S )N)Údevicez
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚtorchÚdiagÚonesÚ num_clientsr ÚPÚ global_modelÚuploaded_modelsÚ uploaded_idsÚminÚMÚ join_clientsÚprintÚ
join_ratio)ÚselfÚargsÚtimes©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverfomo.pyr s
zFedFomo.__init__c C sš t | jd ƒD ]`}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qX| ¡ qtdƒ tt
| j ƒƒ | ¡ |
¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚreceive_modelsÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r ÚiÚclientr r r r' s
z
FedFomo.trainc C sø t | jƒdksJ ‚| jD ]Ú}t ¡ }|jrDt dt tj ¡ ¡ ¡ t | j ƒdkrÂt
| j t | j ƒƒ}t
| j|j | j |¡j ¡ }g }g }|D ]$}| | j | ¡ | | j | ¡ q�| ||¡ |jd d7 < |jd dt ¡ | 7 < qd S )Nr gš™™™™™¹?Ú
num_roundsr Ú
total_costé )Úlenr# ÚtimeÚ send_slowÚsleepÚnpÚabsÚrandomÚrandr r r r r Útopkr ÚidÚindicesÚtolistÚappendr( Úsend_time_cost)r r. Ú
start_timeZM_r< r r r- r r r r$ 9 s
zFedFomo.send_modelsc C sø t | jƒdksJ ‚t | jtd| j | j ƒ¡}g | _g | _d}g | _ |D ]†}|j
d |j
d |j d |j d }|| j krJ| j
|j¡ | j
|j¡ ||j7 }| j
t |j¡¡ | j|j |j7 < qJt| jƒD ]\}}|| | j|< qÜd S )Nr r r0 r/ )r2 r# r8 ÚsampleÚintÚclient_drop_rater r Úuploaded_weightsr Útrain_time_costr? Útime_thretholdr> r; Ú
train_samplesÚcopyÚdeepcopyÚmodelr Z
weight_vectorÚ enumerate)r Zactive_clientsÚ tot_samplesr. Zclient_time_costr- Úwr r r r( P s( ÿÿ
zFedFomo.receive_models)Ú__name__Ú
__module__Ú __qualname__r r' r$ r( Ú
__classcell__r r r r r s r )
r r3 rH r8 Únumpyr6 Zflcore.clients.clientfomor Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 3,014 | Python | .py | 26 | 114.807692 | 501 | 0.457009 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,770 | serverditto.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverditto.cpython-39.pyc | a
f¾`cü ã @ sH d dl Z d dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZdS )é N)Ú clientDitto)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚDittoc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverditto.pyr s zDitto.__init__c C s
t | jd ƒD ] }t ¡ }| ¡ | _| ¡ || j dkrZtd|› d�ƒ tdƒ | ¡ | jD ]}| ¡ |
¡ q`| ¡ | ¡ | j
t ¡ | ¡ tddd| j
d ƒ qtd ƒ tt| jƒƒ td
ƒ tt| j
dd … ƒt| j
dd … ƒ ƒ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateZptrainÚtrainÚreceive_modelsÚaggregate_parametersr
ÚappendÚmaxÚ rs_test_accÚsumÚlenÚ save_resultsÚsave_global_model)r ÚiÚs_tÚclientr r r r s*
(z Ditto.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r ) ÚcopyZflcore.clients.clientdittor Úflcore.servers.serverbaser Ú threadingr r r r r r r Ú<module> s
| 1,777 | Python | .py | 17 | 103.235294 | 343 | 0.488927 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,771 | serverfomo.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverfomo.cpython-37.pyc | B
¸:cci ã @ s` d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlm Z d dl
m Z G dd„ de ƒZ dS )é N)Ú
clientFomo)ÚServer)ÚThreadc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚFedFomoc s€ t ƒ ||¡ | ¡ | |t¡ t tj| j| j d�¡| _
| j g| _ g | _
t|j| jƒ| _td| j› d| j› �ƒ tdƒ d S )N)Údevicez
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚtorchÚdiagÚonesÚ num_clientsr ÚPÚ global_modelÚuploaded_modelsÚ uploaded_idsÚminÚMÚ join_clientsÚprintÚ
join_ratio)ÚselfÚargsÚtimes)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverfomo.pyr s
zFedFomo.__init__c C s¢ xvt | jd ƒD ]d}| ¡ | _| ¡ || j dkrTtd|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ q\W | ¡ qW tdƒ tt
| j ƒƒ | ¡ |
¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚreceive_modelsÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r ÚiÚclientr r r r& s
z
FedFomo.trainc C s t | jƒdkst‚xè| jD ]Ş}t ¡ }|jrFt dt tj ¡ ¡ ¡ t | j
ƒdkrÈt | j t | j
ƒƒ}t | j|j | j
|¡j ¡ }g }g }x,|D ]$}| | j
| ¡ | | j
| ¡ q”W | ||¡ |jd d7 < |jd dt ¡ | 7 < qW d S )Nr gš™™™™™¹?Ú
num_roundsr Ú
total_costé )Úlenr" ÚAssertionErrorÚtimeÚ send_slowÚsleepÚnpÚabsÚrandomÚrandr r r r r Útopkr ÚidÚindicesÚtolistÚappendr' Úsend_time_cost)r r- Ú
start_timeZM_r< r r r, r r r r# 9 s
zFedFomo.send_modelsc C s t | jƒdkst‚t | jtd| j | j ƒ¡}g | _g | _ d}g | _
x�|D ]†}|j d |j d |j d |j d }|| j
krL| j |j¡ | j |j¡ ||j7 }| j
t |j¡¡ | j|j |j7 < qLW x$t| j ƒD ]\}}|| | j |< qâW d S )Nr r r/ r. )r1 r" r2 r8 ÚsampleÚintÚclient_drop_rater r Úuploaded_weightsr Útrain_time_costr? Útime_thretholdr> r; Ú
train_samplesÚcopyÚdeepcopyÚmodelr Z
weight_vectorÚ enumerate)r Zactive_clientsÚ tot_samplesr- Zclient_time_costr, Úwr r r r' P s$
zFedFomo.receive_models)Ú__name__Ú
__module__Ú __qualname__r r& r# r' Ú
__classcell__r r )r r r s r )
r r3 rH r8 Únumpyr6 Zflcore.clients.clientfomor Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 2,989 | Python | .py | 26 | 113.807692 | 422 | 0.45614 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,772 | serverapfl.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverapfl.cpython-39.pyc | a
f¾`c® ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú
clientAPFL)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚAPFLc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverapfl.pyr s
z
APFL.__init__c C s¢ t | jd ƒD ]h}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qX| ¡ |
¡ qtdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s
z
APFL.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s
r N)Zflcore.clients.clientapflr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,492 | Python | .py | 17 | 86.529412 | 225 | 0.500678 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,773 | serverbn.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverbn.cpython-38.pyc | U
”jfcã ã @ sL d dl mZ d dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZ dS )é )ÚclientBN)ÚServer)Úread_client_data)ÚThreadNc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚFedBNc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õJ D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\servers\serverbn.pyr s
zFedBN.__init__c C s¢ t | jd ƒD ]h}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qX| ¡ |
¡ qtdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r ÚiÚclientr r r r s
z FedBN.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s
r )
Zflcore.clients.clientbnr Úflcore.servers.serverbaser Úutils.data_utilsr Ú threadingr Útimer r r r r Ú<module> s
| 1,526 | Python | .py | 16 | 94.125 | 358 | 0.494375 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,774 | serverreppt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverreppt.cpython-38.pyc | U
Õ şc¡ ã @ sp d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z
d dlZd dl Z G dd„ deƒZ
dS )é )Ú clientREPPT)ÚServer)ÚThreadNc sN e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zdd d
„Zdd„ Z ‡ Z
S )Ú PFedRepPTc sn t ƒ ||¡ || _| ¡ | |t¡ t |jj ¡| _
g | _ g | _ t
d| j› d| j› �ƒ t
dƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr ÚcopyÚdeepcopyÚmodelÚbaseÚ global_modelÚdiff_proÚclients_divergeÚprintÚ
join_ratioÚ num_clientsÚBudget)Úselfr Útimes©Ú __class__© õc D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\serverreppt.pyr s zPFedRepPT.__init__c C sú g }t | jd ƒD �]n}t ¡ }| ¡ | _| ¡ || j dkr`td|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }||
¡ }qjd}t | j d j
j ¡ | j d j
j ¡ ƒD ]:\}} || }
t |
dk|
t |
¡|
¡}
|t |
¡ }q®td |
¡ ¡ƒ | j |
¡ ¡ td |¡ƒ | j |¡ || j dk�rJtdƒ | j|d � | ¡ | ¡ | j t ¡ | ¡ td
d d
| jd ƒ qtd
ƒ tt| j ƒƒ tdƒ tt| jdd … ƒt | jdd … ƒ ƒ tdƒ tt|ƒƒ | ¡ | ¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz"0 and 1 clients difference: {:.4f}z"Averaged prompr difference: {:.4f}z
Evaluate local model)Úaccz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.z
Best local accuracy.)!ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚzipÚclientsr
Ú generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumÚformatr Úappendr Úreceive_modelsÚaggregate_parametersr ÚmaxÚ rs_test_accÚlenÚ save_resultsÚsave_global_modelÚsave_client_model) r Ú local_accÚiÚs_tÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r' sL
. ( zPFedRepPT.trainc C s„ t | jƒdkst‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]:}| j |j| ¡ | j |j¡ | j t
|j j ¡¡ qDd S )Nr )
r7 r# ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr2 Úidr r r
r )r Úactive_train_samplesr? r r r r3 Q s
zPFedRepPT.receive_modelsc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsr? Ú*Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsÚ enumerater* Ú algorithmÚstrÚ
num_promptr r Ú plocal_stepsr r- Úsaver
)r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r: _ s T
pzPFedRepPT.save_client_modelc C s€ | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r||d | j d t| jƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd � |jd
| j d � |jd | j d � |jd | j d � |jd
| j d � |jd| j d � W 5 Q R X d S )NrN z ../results/rL ú/z{}.h5z File path: Úwr6 )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )!rR r\ r rS rT rU rV rW rX rO rP rY rZ r7 r6 Úgoalr] r r^ r r r_ r r1 r Úh5pyÚFileÚcreate_datasetrh ri rj r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r8 g s L
l zPFedRepPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Né ç ğ?r é é c S s g | ]\}}|| ‘qS r r ©Ú.0ÚaÚnr r r Ú
<listcomp>‚ s z&PFedRepPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r r rw r r r r{ ƒ s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr0 r) r6 r2 ri rh ÚnpÚstdrj r r1 ) r r ÚlossÚstatsÚ stats_trainÚtest_accÚ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr r r r& y s,
zPFedRepPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nrt c S s g | ]
}|j ‘qS r )rI )rx rc r r r r{ ¦ s z*PFedRepPT.test_metrics.<locals>.<listcomp>)r* r| r2 ) r Ú num_samplesÚ tot_correctÚ tot_correct2Útot_aucrc ÚctÚct2ÚnsÚaucÚidsr r r r| — s
zPFedRepPT.test_metrics)NN) Ú__name__Ú
__module__Ú __qualname__r r' r3 r: r8 r& r| Ú
__classcell__r r r r r s 4
r )Zflcore.clients.clientrepptr Úflcore.servers.serverbaser Ú threadingr r! r r- rO rl Únumpyr~ r r r r r Ú<module> s | 6,136 | Python | .py | 58 | 104.534483 | 497 | 0.430005 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,775 | serverper.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverper.cpython-37.pyc | B
¿:ccî ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú clientPer)ÚServer)ÚThreadc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedPerc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverper.pyr s
zFedPer.__init__c C sª x~t | jd ƒD ]l}| ¡ | _| ¡ || j dkrTtd|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ q\W | ¡ |
¡ qW tdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s
z FedPer.trainc C s˜ t | jƒdkst‚g | _d}g | _g | _xD| jD ]:}| j |j¡ ||j7 }| j |j¡ | j |j j
¡ q0W x$t | jƒD ]\}}|| | j|< qzW d S )Nr ) Úlenr ÚAssertionErrorÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsÚappendÚ
train_samplesÚidÚmodelÚbaseÚ enumerate)r
Ú tot_samplesr# r" Úwr r r r 2 s
zFedPer.receive_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r )r r r s
r N)Zflcore.clients.clientperr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,883 | Python | .py | 14 | 133.214286 | 315 | 0.483422 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,776 | serverdynpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverdynpt.cpython-38.pyc | U
œMgc| ã @ sh d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlZd dl Z d dl Z d dl
Z
G dd„ deƒZ dS )é N)Ú clientDynPT)ÚServer)ÚThreadc sD e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zd d „ Z‡ Z S )
ÚFedDynPTc sŒ t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _g | _ |j
| _
g | _ t
|j¡| _| j ¡ D ]}t |j¡|_qtd S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚdiff_proÚalphaÚclients_divergeÚcopyÚdeepcopyÚmodelÚ server_stateÚ
parametersÚtorchÚ
zeros_likeÚdata)ÚselfÚargsÚtimesÚparam©Ú __class__© õF D:\京东\promot\cifar\cifar\tiny\system\flcore\servers\serverdynpt.pyr s zFedDynPT.__init__c C s g }d| _ d}t| jd ƒD �]�}t ¡ }| ¡ | _| ¡ || j dkrjtd|› d�ƒ tdƒ | ¡ d}| jD ]}|
¡ }|| ¡ }qttd |¡ƒ | j
|¡ d}t| jd jj ¡ | jd jj ¡ ƒD ]:\}} || }
t |
dk|
t |
¡|
¡}
|t |
¡ }qÒtd | ¡ ¡ƒ | j | ¡ ¡ || j dk�rTtd ƒ | j |d
� | ¡ | ¡ | ¡ | j t ¡ | ¡ td | j d ƒ | j | j g| j d
�| _ |d7 }q tdƒ tt | j ƒƒ tdƒ tt |ƒƒ tdƒ tt| j dd … ƒt!| j dd … ƒ ƒ | "¡ | #¡ d S )NFr é z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cntz
Best global accuracy.z
Best local accuracy.z
Averaged time per iteration.)$ÚdoneÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsr Ú generatorr r Úwherer Úsumr Úreceive_modelsÚupdate_server_stateÚaggregate_parametersr
Ú
check_doneÚ rs_test_accr% ÚmaxÚlenÚ save_resultsÚsave_global_model) r Ú local_accÚiÚs_tÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r/ sT
.
(zFedDynPT.trainc C s< t | j ¡ | ¡ ƒD ]"\}}| j|j ¡ | j 7 _qd S )N)r3 Ú global_modelr r ÚcloneÚ join_clients)r Ú client_modelÚ server_paramÚ client_paramr r r Úadd_parameters\ s zFedDynPT.add_parametersc C s” t | jƒdkst‚t | jd ¡| _| j ¡ D ]}t |j ¡|_ q.| jD ]}|
|¡ qHt | j ¡ | j ¡ ƒD ] \}}| j d| j
| 8 _ qnd S )Nr r! )r> Úuploaded_modelsÚAssertionErrorr r rJ r r r r rP r3 r r )r r rM rN Ú state_paramr r r r: ` s
z FedDynPT.aggregate_parametersc C s¾ t | jƒdkst‚t | jd ¡}| ¡ D ]}t |j¡|_q*| jD ]B}t | j
¡ | ¡ | ¡ ƒD ]"\}}}| j|| | j 7 _qbqDt | j ¡ | ¡ ƒD ] \}}| j| j
| 8 _qœd S )Nr )r> rQ rR r r r r r r r3 rJ r r r )r Ú model_deltar rM rN rO Ú delta_paramrS r r r r9 m s
ÿ z FedDynPT.update_server_statec C sÖ | j d | j }d}tj |¡s*t |¡ t| jƒrÒ|d | j d t | j
ƒ }|d |¡ }t d| ƒ t
|d¡�V}|jd| jd� |jd| jd� |jd | jd� |jd
| jd� |jd | jd� W 5 Q R X d S ) NÚ_z ../results/z{}.h5z File path: Úwr< )r Úrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr )ÚdatasetÚ algorithmÚosÚpathÚexistsÚmakedirsr> r< ÚgoalÚstrr r1 r
Úh5pyÚFileÚcreate_datasetrX rY rZ r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r? | s
zFedDynPT.save_results)
Ú__name__Ú
__module__Ú __qualname__r r/ rP r: r9 r? Ú
__classcell__r r r r r s <
r ) r r Zflcore.clients.clientdynptr Úflcore.servers.serverbaser Ú threadingr r) rc r] r r r r r Ú<module> s | 4,433 | Python | .py | 43 | 101.930233 | 403 | 0.438169 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,777 | serverfedpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverfedpt.cpython-38.pyc | U
[ÐýcÇ ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z
G dd„ deƒZ dS )é )ÚclientT)ÚServer)ÚThreadNc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Z‡ ZS ) ÚFedPTc sn t ƒ ||¡ || _| ¡ | |t¡ t |jj ¡| _
g | _ g | _ t
d| j› d| j› �ƒ t
dƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr ÚcopyÚdeepcopyÚmodelÚbaseÚ global_modelÚdiff_proÚclients_divergeÚprintÚ
join_ratioÚ num_clientsÚBudget)Úselfr Útimes©Ú __class__© õY D:\京东\promot\第二次投稿\实验\native - pro\system\flcore\servers\serverfedpt.pyr s zFedPT.__init__c
C s¾ t | jd ƒD �]J}t ¡ }| ¡ | _| ¡ || j dkr\td|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }||
¡ }qfd}t | j d j
j ¡ | j d j
j ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qªtd |¡ƒ td |
¡ ¡ƒ | j |¡ | j |
¡ ¡ | ¡ | ¡ | j t ¡ | ¡ tdd d| jd
ƒ qtd ƒ tt| j ƒƒ td ƒ tt| jdd … ƒt | jdd … ƒ ƒ | ¡ | ¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)!ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚzipÚclientsr
Ú generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumÚformatr Úappendr Úreceive_modelsÚaggregate_parametersr ÚmaxÚ rs_test_accÚlenÚ save_resultsÚsave_global_modelÚsave_client_model)
r ÚiÚs_tÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r& s@
. (z FedPT.trainc C s„ t | jƒdkst‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]:}| j |j| ¡ | j |j¡ | j t
|j j ¡¡ qDd S )Nr )
r6 r" ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr1 Úidr r r
r )r Úactive_train_samplesr= r r r r2 P s
zFedPT.receive_modelsc C s¾ t j d| jd¡}t j |¡s(t |¡ t| jƒD ]†\}}t j || jd t |ƒ d t | j
j ƒ d t | j
j ƒ d t | j
j
ƒ d t | j
jƒ d t | j
jƒ d ¡}t |j|¡ q2d S )NÚmodelsr= Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetÚexistsÚmakedirsÚ enumerater) Ú algorithmÚstrr Ú
num_promptr r Ú plocal_stepsr r, Úsaver
)r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r9 ^ s
pzFedPT.save_client_modelc C s8 | j d | j }d}tj |¡s*t |¡ t| jƒ�r4|d | j d t | j
ƒ d t | j j ƒ d t | j j
ƒ d t | j jƒ d t | j jƒ d t | j jƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd� |jd| jd� |jd | jd� |jd
| jd� |jd | jd� |jd | jd� W 5 Q R X d S )
NrK z ../results/z{}.h5z File path: Úwr5 )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )rO rS rL rM rP rQ r6 r5 ÚgoalrT r r rU r r rV r r0 r Úh5pyÚFileÚcreate_datasetr^ r_ r` r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r7 f s
l zFedPT.save_results) Ú__name__Ú
__module__Ú __qualname__r r& r2 r9 r7 Ú
__classcell__r r r r r
s
3r ) Zflcore.clients.clienttr Úflcore.servers.serverbaser Ú threadingr r r, rL rb r r r r r r Ú<module> s | 4,035 | Python | .py | 39 | 102.230769 | 397 | 0.451839 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,778 | serverdynpt.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverdynpt.cpython-39.pyc | a
»¢bc ã @ sP d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZ dS )é N)Ú clientDynPT)ÚServer)ÚThreadc sD e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zd d „ Z‡ Z S )
ÚFedDynPTc s€ t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _|j | _ t
|j ¡| _
| j
¡ D ]}t |j¡|_qhd S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚalphaÚcopyÚdeepcopyÚmodelÚ server_stateÚ
parametersÚtorchÚ
zeros_likeÚdata)ÚselfÚargsÚtimesÚparam©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverdynpt.pyr
s zFedDynPT.__init__c C sh g }d| _ d}t| jd ƒD ]Ü}t ¡ }| ¡ | _| ¡ || j dkrhtd|› d�ƒ tdƒ | ¡ | jD ] }|
¡ qn|| j dkržtdƒ | j |d� | ¡ | ¡ |
¡ | j t ¡ | ¡ td | jd
ƒ | j| jg| jd �| _ |d7 }q td ƒ tt| jƒƒ td
ƒ tt|ƒƒ tdƒ tt| jdd … ƒt| jdd … ƒ ƒ | ¡ | ¡ d S )NFr é z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cntz
Best global accuracy.z
Best local accuracy.z
Averaged time per iteration.)ÚdoneÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚupdate_server_stateÚaggregate_parametersr
ÚappendÚ
check_doneÚ rs_test_accr# ÚmaxÚsumÚlenÚ save_resultsÚsave_global_model)r Ú local_accÚiÚs_tÚclientr r r r- s>
(zFedDynPT.trainc C s< t | j ¡ | ¡ ƒD ]"\}}| j|j ¡ | j 7 _qd S )N)ÚzipÚ global_modelr r ÚcloneÚ join_clients)r Ú client_modelÚ server_paramÚ client_paramr r r Úadd_parametersO s zFedDynPT.add_parametersc C s” t | jƒdksJ ‚t | jd ¡| _| j ¡ D ]}t |j¡|_q.| jD ]}| |¡ qHt
| j ¡ | j ¡ ƒD ] \}}| jd| j | 8 _qnd S )Nr r )
r6 Úuploaded_modelsr r r> r r r r rD r= r r )r r rA rB Ú state_paramr r r r0 S s
z FedDynPT.aggregate_parametersc C s¾ t | jƒdksJ ‚t | jd ¡}| ¡ D ]}t |j¡|_q*| jD ]B}t| j ¡ | ¡ | ¡ ƒD ]"\}}}| j|| | j
7 _qbqDt| j ¡ | ¡ ƒD ] \}}| j| j | 8 _qœd S ©Nr )
r6 rE r r r r r r r= r> r r r )r Ú model_deltar rA rB rC Ú delta_paramrF r r r r/ ` s
ÿ z FedDynPT.update_server_statec C s‚ t | jƒdksJ ‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]8}| j |j| ¡ | j |j¡ | j t |j
¡¡ qDd S rG ) r6 r) Ú
train_samplesÚuploaded_weightsÚ uploaded_idsrE r1 Úidr r r )r Úactive_train_samplesr< r r r r. n s
zFedDynPT.receive_models)
Ú__name__Ú
__module__Ú __qualname__r r- rD r0 r/ r. Ú
__classcell__r r r r r s 2
r )
r r Z!system.flcore.clients.clientdynptr Ú system.flcore.servers.serverbaser Ú threadingr r' r r r r r Ú<module> s | 3,712 | Python | .py | 34 | 107.970588 | 413 | 0.437075 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,779 | servermtl.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/servermtl.cpython-38.pyc | U
ºĞıcå ã @ s@ d dl Z d dlmZ d dlmZ d dlmZ G dd„ deƒZdS )é N)Ú clientMTL)ÚServer)ÚThreadc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚFedMTLc sÈ t ƒ ||¡ t| | j¡ƒ| _tj| j| jf|j d�| _
|j | _ t | j| jf¡}t | jdf¡}|d| j | |j
¡ d }| |j ¡| _| ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )N©Údeviceé é z
Join clients / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__ÚlenÚflattenÚ global_modelÚdimÚtorchÚzerosÚ join_clientsr ÚW_globÚonesÚmmÚTÚtoÚomegaÚset_slow_clientsÚ set_clientsr ÚprintÚ num_clients)ÚselfÚargsÚtimesÚIÚir ©Ú __class__© õW D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\servers\servermtl.pyr s zFedMTL.__init__c C sæ g }t | jd ƒD ]”}| ¡ | _| ¡ || j dkrVtd|› d�ƒ tdƒ | ¡ t| jƒD ]"\}}| | j
| j |¡ | ¡ q`|| j dkrtdƒ | j|d� qtdƒ tt
| jƒƒ td ƒ tt
|ƒƒ | ¡ | ¡ d S )
Nr r z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚaggregate_parametersÚeval_gapr ÚevaluateÚ enumerateZreceive_valuesr r ÚtrainÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r Ú local_accr! ÚidxÚclientr$ r$ r% r/ s(
z FedMTL.trainc s, | ¡ ‰ ˆ ¡ }‡ fdd„|D ƒ}t |¡S )Nc s g | ]}ˆ | ¡ ‘qS r$ )r
)Ú.0Úkey©Ú
state_dictr$ r% Ú
<listcomp>@ s z"FedMTL.flatten.<locals>.<listcomp>)r: Úkeysr Úcat)r Úmodelr< ÚWr$ r9 r% r
= s zFedMTL.flattenc C sL t j| j| jf| jd�| _t| jƒD ]"\}}| |j ¡| jd d …|f< q$d S )Nr )
r r r r r r r. r* r
r> )r r5 r6 r$ r$ r% r+ C s zFedMTL.aggregate_parameters)Ú__name__Ú
__module__Ú __qualname__r r/ r
r+ Ú
__classcell__r$ r$ r" r% r s !r )r Zflcore.clients.clientmtlr Úflcore.servers.serverbaser Ú threadingr r r$ r$ r$ r% Ú<module> s | 2,520 | Python | .py | 17 | 147.058824 | 582 | 0.436502 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,780 | serverpFedMe.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverpFedMe.cpython-38.pyc | U
”jfcE ã @ sP d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ G dd„ deƒZ dS )é N)Ú clientpFedMe)ÚServer)ÚThreadc sL e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zd d „ Zd
d„ Z ‡ Z
S )ÚpFedMec s` t ƒ ||¡ | ¡ | |t¡ |j| _g | _g | _g | _t d| j
› d| j › �ƒ t dƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚbetaÚrs_train_acc_perÚrs_train_loss_perÚrs_test_acc_perÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õN D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\servers\serverpFedMe.pyr
s zpFedMe.__init__c C sÀ t | jd ƒD ]†}| ¡ | _| ¡ | jD ] }| ¡ q*|| j dkrftd|› d�ƒ tdƒ | ¡ t
t | j
¡ ƒ¡| _| ¡ | ¡ | ¡ qtdƒ tt| jƒƒ | ¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate personalized modelz
Best personalized results.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚtrainÚeval_gapr Úevaluate_personalized_modelÚcopyÚdeepcopyÚlistÚ global_modelÚ
parametersÚprevious_global_modelÚreceive_modelsÚaggregate_parametersÚbeta_aggregate_parametersÚmaxr
Ú save_resultsÚsave_global_model)r ÚiÚclientr r r r s"
z pFedMe.trainc C s> t | j| j ¡ ƒD ]&\}}d| j |j | j|j |_qd S )Nr )Úzipr& r$ r% r
Údata)r Z pre_paramÚparamr r r r) D s z pFedMe.beta_aggregate_parametersc C sR g }g }| j D ](}| ¡ \}}| |d ¡ | |¡ qdd„ | j D ƒ}|||fS )Nç ğ?c S s g | ]
}|j ‘qS r ©Úid©Ú.0Úcr r r Ú
<listcomp>P s z4pFedMe.test_metrics_personalized.<locals>.<listcomp>)ÚclientsÚtest_metrics_personalizedÚappend)r Ú num_samplesÚ tot_correctr7 ÚctÚnsÚidsr r r r: I s
z pFedMe.test_metrics_personalizedc C sh g }g }g }| j D ]8}| ¡ \}}}| |d ¡ | |¡ | |d ¡ qdd„ | j D ƒ}||||fS )Nr2 c S s g | ]
}|j ‘qS r r3 r5 r r r r8 ^ s z5pFedMe.train_metrics_personalized.<locals>.<listcomp>)r9 Útrain_metrics_personalizedr; ) r r< r= Úlossesr7 r> Úclr? r@ r r r rA T s
z!pFedMe.train_metrics_personalizedc C sB | ¡ }t|d ƒd t|d ƒ }| j |¡ td |¡ƒ d S )Né r2 r z+Average Personalized Test Accurancy: {:.4f})r: Úsumr
r; r Úformat)r ÚstatsÚtest_accr r r r b s z"pFedMe.evaluate_personalized_modelc C s¦ | j d | j }d}tj |¡s*t |¡ t| jƒr¢|d | j d t | j
ƒ }t |d
|¡ d¡�6}|jd| jd� |jd| jd� |jd| jd� W 5 Q R X d S ) NÚ_z ../results/z{}.h5ÚwÚ rs_test_acc)r0 Z rs_train_accÚ
rs_train_loss)ÚdatasetÚ algorithmÚosÚpathÚexistsÚmakedirsÚlenr
ÚgoalÚstrr Úh5pyÚFilerF Úcreate_datasetr r )r ÚalgoÚ result_pathZalgo2Úhfr r r r+ q s
zpFedMe.save_results) Ú__name__Ú
__module__Ú __qualname__r r r) r: rA r r+ Ú
__classcell__r r r r r s + r )
rO r! rV Zflcore.clients.clientpFedMer Zflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 3,780 | Python | .py | 28 | 133.714286 | 434 | 0.460144 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,781 | serverprox.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverprox.cpython-39.pyc | a
f¾`c² ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú
clientProx)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚFedProxc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverprox.pyr s
zFedProx.__init__c C s¢ t | jd ƒD ]h}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qX| ¡ |
¡ qtdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s
z
FedProx.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r N)Zflcore.clients.clientproxr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,501 | Python | .py | 16 | 92.5625 | 225 | 0.504038 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,782 | serverlocalpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverlocalpt.cpython-38.pyc | U
şc4 ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z G dd„ deƒZ dS )é )Ú clientAVGPT)ÚServer)ÚThreadNc sN e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zdd d
„Zdd„ Z ‡ Z
S )ÚLocalPTc sX t ƒ ||¡ || _| ¡ | |t¡ g | _g | _td| j › d| j
› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr Údiff_proÚclients_divergeÚprintÚ
join_ratioÚ num_clients)Úselfr Útimes©Ú __class__© õe D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\serverlocalpt.pyr s zLocalPT.__init__c
C sŠ g }t | jd ƒD �].}| ¡ | _|| j dkrPtd|› d�ƒ tdƒ | ¡ | ¡ | _d}| jD ]}| ¡ }|| ¡ }qdtd |¡ƒ | j
|¡ d}t | j
d jj ¡ | j
d jj ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qÂtd | ¡ ¡ƒ | j | ¡ ¡ || j dkrtdƒ | j|d � qtd
ƒ tt| jƒƒ td ƒ tt|ƒƒ | ¡ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚeval_gapr
ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsÚmodelÚ generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr ÚmaxÚ rs_test_accÚ save_resultsÚsave_global_modelÚsave_client_model)
r Ú local_accÚiÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r sB
ÿ z
LocalPT.trainc C s„ t | jƒdkst‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]:}| j |j| ¡ | j |j¡ | j t
|j j ¡¡ qDd S )Nr )
Úlenr ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr! ÚidÚcopyÚdeepcopyr$ Úbase)r Úactive_train_samplesr3 r r r Úreceive_modelsD s
zLocalPT.receive_modelsc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsr3 Ú*Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsÚ enumerater# Ú algorithmÚstrÚ
num_promptr r Ú plocal_stepsr r' Úsaver$ )r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r/ R s T
pzLocalPT.save_client_modelc C s€ | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r||d | j d t| jƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd � |jd
| j d � |jd | j d � |jd | j d � |jd
| j d � |jd| j d � W 5 Q R X d S )NrG z ../results/rE ú/z{}.h5z File path: Úwr, )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )!rK rU r rL rM rN rO rP rQ rH rI rR rS r8 r, ÚgoalrV r rW r r rX r r r
Úh5pyÚFileÚcreate_datasetra rb rc r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r- Z s L
l zLocalPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Né ç ğ?r é é c S s g | ]\}}|| ‘qS r r ©Ú.0ÚaÚnr r r Ú
<listcomp>v s z$LocalPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r r rp r r r rt w s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr* r" r, r! rb ra ÚnpÚstdrc r
r ) r r ÚlossÚstatsÚ stats_trainÚtest_accÚ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr r r r m s,
zLocalPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nrm c S s g | ]
}|j ‘qS r )r> )rq r\ r r r rt ™ s z(LocalPT.test_metrics.<locals>.<listcomp>)r# ru r! ) r Ú num_samplesÚ tot_correctÚ tot_correct2Útot_aucr\ ÚctÚct2ÚnsÚaucÚidsr r r ru Œ s
zLocalPT.test_metrics)NN) Ú__name__Ú
__module__Ú __qualname__r r rC r/ r- r ru Ú
__classcell__r r r r r
s
,
r )
Zflcore.clients.clientavgptr Úflcore.servers.serverbaser Ú threadingr r' rH re r? Únumpyrw r r r r r Ú<module> s | 5,768 | Python | .py | 51 | 111.823529 | 495 | 0.428821 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,783 | serverdyn.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverdyn.cpython-37.pyc | B
¿:cc ã @ sP d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZ dS )é N)Ú clientDyn)ÚServer)ÚThreadc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Z‡ ZS ) ÚFedDync s„ t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _|j | _ t
|j ¡| _
x | j
¡ D ]}t |j¡|_qjW d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚalphaÚcopyÚdeepcopyÚmodelÚ server_stateÚ
parametersÚtorchÚ
zeros_likeÚdata)ÚselfÚargsÚtimesÚparam)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverdyn.pyr
s zFedDyn.__init__c C sp g }d| _ d}xòt| jd ƒD ]à}t ¡ }| ¡ | _| ¡ || j dkrjtd|› d�ƒ tdƒ | ¡ x| jD ] }|
¡ qrW || j dkr¤tdƒ | j |d� | ¡ | ¡ |
¡ | j t ¡ | ¡ td | jd
ƒ | j| jg| jd �| _ |d7 }q W td ƒ tt| jƒƒ td
ƒ tt|ƒƒ tdƒ tt| jdd … ƒt| jdd … ƒ ƒ | ¡ | ¡ d S )NFr é z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cntz
Best global accuracy.z
Best local accuracy.z
Averaged time per iteration.)ÚdoneÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚupdate_server_stateÚaggregate_parametersr
ÚappendÚ
check_doneÚ rs_test_accr" ÚmaxÚsumÚlenÚ save_resultsÚsave_global_model)r Z local_accÚiÚs_tÚclientr r r r, s>
(z FedDyn.trainc C s@ x:t | j ¡ | ¡ ƒD ]"\}}| j|j ¡ | j 7 _qW d S )N)ÚzipÚ global_modelr r ÚcloneÚ join_clients)r Ú client_modelÚ server_paramÚ client_paramr r r Úadd_parametersO s zFedDyn.add_parametersc C s t | jƒdkst‚t | jd ¡| _x | j ¡ D ]}t |j ¡|_ q0W x| jD ]}|
|¡ qNW x:t | j ¡ | j ¡ ƒD ] \}}| j d| j
| 8 _ qxW d S )Nr r )r5 Úuploaded_modelsÚAssertionErrorr r r< r r r r rB r; r r )r r r? r@ Ú state_paramr r r r/ S s zFedDyn.aggregate_parametersc C sÎ t | jƒdkst‚t | jd ¡}x | ¡ D ]}t |j¡|_q,W xP| jD ]F}x@t | j
¡ | ¡ | ¡ ƒD ]"\}}}| j|| | j 7 _qjW qJW x4t | j ¡ | ¡ ƒD ] \}}| j| j
| 8 _qªW d S )Nr )r5 rC rD r r r r r r r; r< r r r )r Z model_deltar r? r@ rA Z delta_paramrE r r r r. ` s & zFedDyn.update_server_state) Ú__name__Ú
__module__Ú __qualname__r r, rB r/ r. Ú
__classcell__r r )r r r s
1
r )
r r Z system.flcore.clients.clientdynr Ú system.flcore.servers.serverbaser Ú threadingr r& r r r r r Ú<module> s | 3,307 | Python | .py | 25 | 130.92 | 435 | 0.439842 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,784 | serverditto.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverditto.cpython-38.pyc | U
”jfcü ã @ sH d dl Z d dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZdS )é N)Ú clientDitto)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚDittoc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes©Ú __class__© õM D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\servers\serverditto.pyr s zDitto.__init__c C s
t | jd ƒD ] }t ¡ }| ¡ | _| ¡ || j dkrZtd|› d�ƒ tdƒ | ¡ | jD ]}| ¡ |
¡ q`| ¡ | ¡ | j
t ¡ | ¡ tddd| j
d ƒ qtd ƒ tt| jƒƒ td
ƒ tt| j
dd … ƒt| j
dd … ƒ ƒ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateZptrainÚtrainÚreceive_modelsÚaggregate_parametersr
ÚappendÚmaxÚ rs_test_accÚsumÚlenÚ save_resultsÚsave_global_model)r ÚiÚs_tÚclientr r r r s*
(z Ditto.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r ) ÚcopyZflcore.clients.clientdittor Úflcore.servers.serverbaser Ú threadingr r r r r r r Ú<module> s
| 1,741 | Python | .py | 17 | 101.117647 | 343 | 0.478841 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,785 | serverprox.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverprox.cpython-37.pyc | B
¿:cc² ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú
clientProx)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚFedProxc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes)Ú __class__© úG/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverprox.pyr s
zFedProx.__init__c C sª x~t | jd ƒD ]l}| ¡ | _| ¡ || j dkrTtd|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ q\W | ¡ |
¡ qW tdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s
z
FedProx.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r )r r r s r N)Zflcore.clients.clientproxr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,451 | Python | .py | 13 | 110.307692 | 227 | 0.496178 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,786 | serverrep.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverrep.cpython-39.pyc | a
ï`c ã @ sH d dl mZ d dlmZ d dlmZ d dlZd dlZG dd„ deƒZdS )é )Ú clientRep)ÚServer)ÚThreadNc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedRepc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverrep.pyr s zFedRep.__init__c C s t | jd ƒD ]˜}t ¡ }| ¡ | _| ¡ || j dkrZtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ q`|
¡ | ¡ | j
t ¡ | ¡ tddd| j d ƒ qtd ƒ tt| jƒƒ td
ƒ tt| j dd … ƒt| j dd … ƒ ƒ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersr
ÚappendÚmaxÚ rs_test_accÚsumÚlenÚ save_resultsÚsave_global_model)r ÚiÚs_tÚclientr r r r s(
(z FedRep.trainc C s„ t | jƒdksJ ‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]:}| j |j| ¡ | j |j¡ | j t |j
j ¡¡ qDd S )Nr ) r& r Ú
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr" ÚidÚcopyÚdeepcopyÚmodelÚbase)r Zactive_train_samplesr+ r r r r : s
zFedRep.receive_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r r r r s #r ) Z system.flcore.clients.clientrepr Ú system.flcore.servers.serverbaser Ú threadingr r r1 r r r r r Ú<module> s
| 2,176 | Python | .py | 19 | 113.263158 | 369 | 0.477294 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,787 | serverbnpt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverbnpt.cpython-38.pyc | U
€fc"
ã @ sl d dl mZ d dlmZ d dlmZ d dlmZ d dlZd dl Z d dl
Z
d dl Z d dl Z G dd„ deƒZ
dS )é )Ú
clientBNPT)ÚServer)Úread_client_data)ÚThreadNc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedBNPTc sR t ƒ ||¡ | ¡ | |t¡ g | _g | _td| j› d| j › �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)
ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr Údiff_proÚclients_divergeÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õL D:\京东\promot\cifar\cifar\Cifar10_iid\system\flcore\servers\serverbnpt.pyr
s zFedBNPT.__init__c C sV t | jd ƒD �]}| ¡ | _| ¡ || j dkrTtd|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }|| ¡ }q^td
|¡ƒ | j |¡ d}t
| jd jj ¡ | jd jj ¡ ƒD ]:\}}|| }t |dk|t |¡| ¡}|t |¡ }q¼td
| ¡ ¡ƒ | j | ¡ ¡ | ¡ | ¡ qtdƒ tt| jƒƒ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Best global accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsÚmodelÚ generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr Úreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model) r ÚiÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r s8
ÿ
z
FedBNPT.trainc C sÖ | j d | j }d}tj |¡s*t |¡ t| jƒrÒ|d | j d t | j
ƒ }|d |¡ }t d| ƒ t
|d¡�V}|jd| jd� |jd| jd� |jd | jd� |jd
| jd� |jd | jd� W 5 Q R X d S ) NÚ_z ../results/z{}.h5z File path: Úwr/ )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr )ÚdatasetÚ algorithmÚosÚpathÚexistsÚmakedirsÚlenr/ ÚgoalÚstrr r! r
Úh5pyÚFileÚcreate_datasetr< r= r> r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r0 C s
zFedBNPT.save_results)Ú__name__Ú
__module__Ú __qualname__r r r0 Ú
__classcell__r r r r r s (r )Zflcore.clients.clientbnptr Úflcore.servers.serverbaser Úutils.data_utilsr Ú threadingr ÚtimerH ÚcopyrA r( r r r r r Ú<module> s | 2,725 | Python | .py | 23 | 117.26087 | 357 | 0.483907 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,788 | serverper.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverper.cpython-38.pyc | U
ºĞıc ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z G dd„ deƒZ dS )é )Ú clientPer)ÚServer)ÚThreadNc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedPerc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õW D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\servers\serverper.pyr s
zFedPer.__init__c C sÜ g }t | jd ƒD ]Š}| ¡ | _| ¡ || j dkrVtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ q\|| j dkrŒtdƒ | j|d� | ¡ |
¡ qtdƒ tt | j ƒƒ td ƒ tt |ƒƒ |
¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
Ú local_accÚiÚclientr r r r s*
z FedPer.trainc C s� t | jƒdkst‚g | _d}g | _g | _| jD ]:}| j |j¡ ||j7 }| j |j¡ | j |j j
¡ q.t | jƒD ]\}}|| | j|< qtd S )Nr ) Úlenr ÚAssertionErrorÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsÚappendÚ
train_samplesÚidÚmodelÚbaseÚ enumerate)r
Ú tot_samplesr& r% Úwr r r r : s
zFedPer.receive_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r r r r
s
"r )
Zflcore.clients.clientperr Úflcore.servers.serverbaser Ú threadingr Úh5pyÚcopyÚosÚtorchÚnumpyÚnpr r r r r Ú<module> s | 2,123 | Python | .py | 23 | 91.130435 | 254 | 0.482151 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,789 | serverprox.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverprox.cpython-38.pyc | U
ºĞıc� ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú
clientProx)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚFedProxc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õX D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\servers\serverprox.pyr s
zFedProx.__init__c C sÜ g }t | jd ƒD ]Š}| ¡ | _| ¡ || j dkrVtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ q\|| j dkrŒtdƒ | j|d� | ¡ |
¡ qtdƒ tt | j ƒƒ td ƒ tt |ƒƒ |
¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
Ú local_accÚiÚclientr r r r s*
z
FedProx.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s r N)Zflcore.clients.clientproxr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,611 | Python | .py | 19 | 83.578947 | 225 | 0.491525 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,790 | serverlocal.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverlocal.cpython-39.pyc | a
f¾`c… ã @ s8 d dl mZ d dlmZ d dlmZ G dd„ deƒZdS )é )Ú clientAVG)ÚServer)ÚThreadc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚLocalc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© út/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serverlocal.pyr s
zLocal.__init__c C s” t | jd ƒD ]Z}| ¡ | _|| j dkrJtd|› d�ƒ tdƒ | ¡ | ¡ | _| jD ] }| ¡ qZqtdƒ tt| j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚeval_gapr
ÚevaluateÚtrainÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r
ÚiÚclientr r r r s
z Local.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s
r N)Zflcore.clients.clientavgr Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 1,425 | Python | .py | 14 | 100.5 | 318 | 0.492918 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,791 | serveramppt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serveramppt.cpython-38.pyc | U
şc£! ã @ sŒ d dl Z d dlZd dlZd dlZd dlZd dlmZmZ d dl m
Z
d dl m Z d dl
Z
d dlZd dlZd dl Z d dlZG dd„ de
ƒZdS )é N)Ú clientAMPPTÚweight_flatten)ÚServer)ÚThreadc s^ e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Zdd d
„Zdd„ Z dd„ Z
dd„ Z ‡ Z S )ÚFedAMPPTc sh t ƒ ||¡ || _| ¡ | |t¡ g | _g | _|j| _|j | _ t
d| j › d| j › �ƒ t
dƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)
ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr Úclients_divergeÚdiff_proÚalphaKÚsigmaÚprintÚ
join_ratioÚ num_clients)Úselfr Útimes©Ú __class__© õc D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\serveramppt.pyr s zFedAMPPT.__init__c
C s’ g }t | jd ƒD �]6}| ¡ | _| ¡ || j dkrXtd|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }|| ¡ }qbtd
|¡ƒ | j |¡ d}t
| jd jj ¡ | jd jj ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qÀtd
| ¡ ¡ƒ | j | ¡ ¡ || j dk�rBtdƒ | j|d � | ¡ qtd
ƒ tt| jƒƒ td ƒ tt|ƒƒ | ¡ | ¡ | ¡ d S ) Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚformatr
ÚappendÚzipÚclientsÚmodelÚ generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr Úreceive_modelsÚmaxÚ rs_test_accÚ save_resultsÚsave_global_modelÚsave_client_model)
r Ú local_accÚiÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr
r r r r" sD
ÿ
zFedAMPPT.trainc C s‚ t | jƒdkst‚d}| jD ]}||j7 }q g | _g | _g | _| jD ]8}| j |j| ¡ | j |j¡ | j t
|j ¡¡ qDd S )Nr ) Úlenr ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr% ÚidÚcopyÚdeepcopyr( )r Úactive_train_samplesr8 r r r r/ K s
zFedAMPPT.receive_modelsc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsr8 Ú*Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsÚ enumerater' Ú algorithmÚstrÚ
num_promptr r Ú plocal_stepsr r+ Úsaver( )r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r4 Y s T
pzFedAMPPT.save_client_modelc C s€ | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r||d | j d t| jƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd � |jd
| j d � |jd | j d � |jd | j d � |jd
| j d � |jd| j d � W 5 Q R X d S )NrJ z ../results/rH ú/z{}.h5z File path: Úwr1 )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr
r )!rN rX r rO rP rQ rR rS rT rK rL rU rV r= r1 ÚgoalrY r rZ r r r[ r r$ r Úh5pyÚFileÚcreate_datasetrd re rf r
r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r2 a s L
l zFedAMPPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Né ç ğ?r é é c S s g | ]\}}|| ‘qS r r ©Ú.0ÚaÚnr r r Ú
<listcomp>} s z%FedAMPPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r r rs r r r rw ~ s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr. r& r1 r% re rd ÚnpÚstdrf r r$ ) r r ÚlossÚstatsÚ stats_trainÚtest_accÚ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr r r r! t s,
zFedAMPPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nrp c S s g | ]
}|j ‘qS r )rC )rt r_ r r r rw s z)FedAMPPT.test_metrics.<locals>.<listcomp>)r' rx r% ) r Ú num_samplesÚ tot_correctÚ tot_correct2Útot_aucr_ ÚctÚct2ÚnsÚaucÚidsr r r rx “ s
zFedAMPPT.test_metricsc
C sŒ t | jƒdkst‚t | jƒdk�rˆ| jD �]\}t | j¡}| ¡ D ]}|j
¡ qBt | j
¡}t| jƒD ]b\}}|j| j| krÂt|jƒ}t|ƒ}|| d¡} t | | ¡} | j| | ¡ ||< qhd||< qhdt |¡ }
t| jƒD ]:\}}t| ¡ | ¡ ƒD ] \}} | j || | 7 _ qşqät ¡ } |j�rJt dt t j ¡ ¡ ¡ | ||
¡ |j!d d7 < |j!d dt ¡ | 7 < q(d S )Nr éÿÿÿÿr gš™™™™™¹?Ú
num_roundsÚ
total_costro )"r= r r> rB r' rD rE Ú global_modelr* rc Úzero_r+ ÚzerosÚ join_clientsrW rC rA r r( ÚviewÚdotr Úer. r& ÚtimeÚ send_slowÚsleeprz ÚabsÚrandomÚrandÚset_parametersÚsend_time_cost)
r r_ ÚmuÚparamÚcoefÚjÚmwÚ weights_iÚ weights_jÚsubÚ coef_selfÚparam_jÚ
start_timer r r r ¥ s2
zFedAMPPT.send_modelsc C s t | | j ¡| j S )N)ÚmathÚexpr )r Úxr r r r— É s z
FedAMPPT.e)NN)
Ú__name__Ú
__module__Ú __qualname__r r" r/ r4 r2 r! rx r r— Ú
__classcell__r r r r r s -
$r )r+ rD r˜ Únumpyrz r« Zflcore.clients.clientampptr r Úflcore.servers.serverbaser Ú threadingr rh rK r r r r r Ú<module> s | 6,980 | Python | .py | 62 | 111.33871 | 496 | 0.421882 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,792 | serverpfedpt.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverpfedpt.cpython-37.pyc | B
�ÑecŞ ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z
G dd„ deƒZ dS )é )ÚclientPT)ÚServer)ÚThreadNc s< e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
„ Z‡ ZS ) ÚPFedPTc sn t ƒ ||¡ | ¡ || _| |t¡ t |jj ¡| _
g | _ g | _ t
d| j› d| j› �ƒ t
dƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚargsÚ set_clientsr ÚcopyÚdeepcopyÚmodelÚbaseÚ global_modelÚdiff_proÚclients_divergeÚprintÚ
join_ratioÚ num_clientsÚBudget)Úselfr Útimes)Ú __class__© úI/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverpfedpt.pyr s zPFedPT.__init__c
C sÌ �xft | jd ƒD �]R}t ¡ }| ¡ | _| ¡ || j dkr`td|› d�ƒ tdƒ | ¡ d}x"| jD ]}| ¡ }||
¡ }qlW td |¡ƒ | j
|¡ d}xdt| jd jj ¡ | jd jj ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qÎW td |
¡ ¡ƒ | j
|
¡ ¡ | ¡ | ¡ | j
t ¡ | ¡ tdd d| jd
ƒ qW td ƒ tt| j ƒƒ td ƒ tt| jdd … ƒt | jdd … ƒ ƒ | ¡ | ¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z-------------------------z time costéÿÿÿÿz
Best global accuracy.z
Average time cost per round.)!ÚrangeÚ
global_roundsÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsr
Ú generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr Úreceive_modelsÚaggregate_parametersr ÚmaxÚ rs_test_accÚlenÚ save_resultsÚsave_global_modelÚsave_client_model)
r ÚiÚs_tZ
temp_diff_proÚclientZtemp_diff_pro_clientZdiverge_clentsÚ new_paramÚ old_paramr r r r r% s@
0 (z PFedPT.trainc C sŒ t | jƒdkst‚d}x| jD ]}||j7 }q W g | _g | _g | _xD| jD ]:}| j |j| ¡ | j |j¡ | j t
|j j ¡¡ qJW d S )Nr )
r5 r! ÚAssertionErrorÚ
train_samplesÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr( Úidr r r
r )r Úactive_train_samplesr; r r r r1 O s zPFedPT.receive_modelsc C s t j d| jd¡}t j |¡s(t |¡ x”t| jƒD ]†\}}t j || jd t |ƒ d t | j
j ƒ d t | j
j ƒ d t | j
j
ƒ d t | j
jƒ d t | j
jƒ d ¡}t |j|¡ q4W d S )NÚmodelsr; Z_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetÚexistsÚmakedirsÚ enumerater* Ú algorithmÚstrr Ú
num_promptr r Ú plocal_stepsr r- Úsaver
)r Ú
model_pathÚc_idxÚcZmodel_path_saver r r r8 ] s
pzPFedPT.save_client_modelc C s8 | j d | j }d}tj |¡s*t |¡ t| jƒ�r4|d | j d t | j
ƒ d t | j j ƒ d t | j j
ƒ d t | j jƒ d t | j jƒ d t | j jƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd� |jd| jd� |jd | jd� |jd
| jd� |jd | jd� |jd | jd� W d Q R X d S )
NrF z ../results/z{}.h5z File path: Úwr4 )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )rJ rN rG rH rK rL r5 r4 ÚgoalrO r r rP r r rQ r r' r Úh5pyÚFileÚcreate_datasetrX rY rZ r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r6 e s
l zPFedPT.save_results) Ú__name__Ú
__module__Ú __qualname__r r% r1 r8 r6 Ú
__classcell__r r )r r r
s
1r ) Z system.flcore.clients.clientptr Ú system.flcore.servers.serverbaser Ú threadingr r r- rG r\ r r r r r r Ú<module> s | 4,038 | Python | .py | 36 | 110.916667 | 397 | 0.459405 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,793 | serverproto.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverproto.cpython-37.pyc | B
¾:ccÜ ã @ sh d dl mZ d dlmZ d dlmZ d dlmZ d dlZd dl Z
d dl m Z G dd„ deƒZ
d d
„ ZdS ) é )Ú clientProto)ÚServer)Úread_client_data)ÚThreadN)Ú defaultdictc s> e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
d „Z‡ ZS )
ÚFedProtoc sj t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _|j | _ dd„ t
|j ƒD ƒ| _ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.c S s g | ]}d ‘qS )N© )Ú.0Ú_r r úH/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverproto.pyú
<listcomp> s z%FedProto.__init__.<locals>.<listcomp>) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚ num_classesÚrangeÚ
global_protos)ÚselfÚargsÚtimes)Ú __class__r r r s zFedProto.__init__c C s& d| _ d}xĞ| j sÚt ¡ }| ¡ | _|| j dkrZ|dkrZtd|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ qbW | ¡ t | j
ƒ| _ | ¡ | j
t ¡ | ¡ td| j
d ƒ |dkrĞ| j| jg| jd�| _ |d 7 }q W td
ƒ tt| jƒƒ tt| j
d d … ƒt| j
d d … ƒ ƒ | ¡ d S ) NFr z
-------------Round number: z
-------------z
Evaluate global modelz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cnté z
Best global accuracy.)ÚdoneÚtimeÚselect_clientsÚselected_clientsÚeval_gapr ÚevaluateÚtrainÚreceive_protosÚproto_aggregationÚuploaded_protosr Ú send_protosr ÚappendÚ
check_doneÚ rs_test_accr ÚmaxÚsumÚlenÚ save_results)r ÚiÚs_tÚclientr r r r& s.
(zFedProto.trainc C s2 t | jƒdkst‚x| jD ]}| | j¡ qW d S )Nr )r0 r# ÚAssertionErrorZ
set_protosr )r r4 r r r r* C s zFedProto.send_protosc C sN t | jƒdkst‚g | _g | _x*| jD ] }| j |j¡ | j |j¡ q&W d S )Nr )r0 r# r5 Ú uploaded_idsr) r+ ÚidÚprotos)r r4 r r r r' I s zFedProto.receive_protosNc C sØ | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ}|d krz| j |¡ n
| |¡ |d krš| j |¡ n
| |¡ td |¡ƒ td |¡ƒ td t
|¡¡ƒ d S ) Né g ğ?r c S s g | ]\}}|| ‘qS r r )r ÚaÚnr r r r X s z%FedProto.evaluate.<locals>.<listcomp>zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}zStd Test Accurancy: {:.4f}) Ú test_metricsÚ
train_metricsr/ Úzipr- r+ Ú
rs_train_lossr ÚformatÚnpÚstd)r ÚaccÚlossÚstatsÚ stats_trainÚtest_accÚ
train_lossÚaccsr r r r% R s
zFedProto.evaluate)NN) Ú__name__Ú
__module__Ú __qualname__r r& r* r' r% Ú
__classcell__r r )r r r
s
( r c C s¦ t tƒ}x0| D ](}x"| ¡ D ]}|| || ¡ q W qW xf| ¡ D ]Z\}}t|ƒdkr�d|d j }x|D ]}||j7 }qlW |t|ƒ ||< qD|d j||< qDW |S )Nr r )r ÚlistÚkeysr+ Úitemsr0 Údata)Zlocal_protos_listZagg_protos_labelZ local_protosÚlabelZ
proto_listÚprotor2 r r r r( k s
r( )Zflcore.clients.clientprotor Úflcore.servers.serverbaser Úutils.data_utilsr Ú threadingr r! ÚnumpyrA Ú collectionsr r r( r r r r Ú<module> s a | 3,696 | Python | .py | 29 | 126.275862 | 475 | 0.439204 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,794 | serverphp.cpython-37.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverphp.cpython-37.pyc | B
¿:cc” ã @ sH d dl mZ d dlmZ d dlmZ d dlZd dlZG dd„ deƒZdS )é )Ú clientPHP)ÚServer)ÚThreadNc s, e Zd Z‡ fdd„Zdd„ Zdd„ Z‡ ZS )ÚFedPHPc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes)Ú __class__© úF/root/autodl-tmp/PFL-Non-IID-master/system/flcore/servers/serverphp.pyr s zFedPHP.__init__c C s¬ x€t | jd ƒD ]n}| ¡ | _| |¡ || j dkrVtd|› d�ƒ tdƒ | ¡ x| jD ] }| ¡ q^W | ¡ |
¡ qW tdƒ tt | j ƒƒ |
¡ | ¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r ÚiÚclientr r r r s
z FedPHP.trainc C s4 t | jƒdkst‚x | jD ]}| | j|¡ qW d S )Nr )Úlenr ÚAssertionErrorÚset_parametersÚ global_model)r ÚRr$ r r r r 5 s zFedPHP.send_models)Ú__name__Ú
__module__Ú __qualname__r r r Ú
__classcell__r r )r r r s r ) Zflcore.clients.clientphpr Úflcore.servers.serverbaser Ú threadingr ÚtimeÚcopyr r r r r Ú<module> s
| 1,724 | Python | .py | 13 | 131.307692 | 338 | 0.484813 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,795 | servermoon.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/servermoon.cpython-39.pyc | a
f¾`c{ ã @ sL d dl mZ d dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZ dS )é )Ú
clientMOON)ÚServer)Úread_client_data)ÚThreadNc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚMOONc sL t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudget)ÚselfÚargsÚtimes©Ú __class__© ús/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/servermoon.pyr s z
MOON.__init__c C sT g }d| _ d}| j sæt ¡ }| ¡ | _| ¡ || j dkr\td|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qb|| j dkr’tdƒ | j|d� | ¡ |
¡ | j t ¡ | ¡ td| j d ƒ | j
| jg| jd
�| _ |d 7 }qtd ƒ tt| jƒƒ td
ƒ tt|ƒƒ tdƒ tt| j d d … ƒt| j d d … ƒ ƒ | ¡ | ¡ d S )NFr z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cnté z
Best global accuracy.z
Best local accuracy.z
Averaged time per iteration.)ÚdoneÚtimeÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersr ÚappendÚ
check_doneÚ rs_test_accr ÚmaxÚsumÚlenÚ save_resultsÚsave_global_model)r Ú local_accÚiÚs_tÚclientr r r r" s<
(z
MOON.train)Ú__name__Ú
__module__Ú __qualname__r r" Ú
__classcell__r r r r r s r )
Zflcore.clients.clientmoonr Úflcore.servers.serverbaser Úutils.data_utilsr Ú threadingr r r r r r r Ú<module> s
| 1,996 | Python | .py | 22 | 89.5 | 412 | 0.482025 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,796 | serverbabupt.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverbabupt.cpython-38.pyc | U
şc ã @ s` d dl mZ d dlmZ d dlmZ d dlZd dlZd dlZd dl Z d dl
Z G dd„ deƒZ dS )é )Ú clientBABUPT)ÚServer)ÚThreadNc sN e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zdd
d „Zd d
„ Zdd„ Z ‡ Z
S )Ú FedBABUPTc sX t ƒ ||¡ || _| ¡ | |t¡ g | _g | _td| j › d| j
› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.) ÚsuperÚ__init__ÚargsÚset_slow_clientsÚ set_clientsr Úclients_divergeÚdiff_proÚprintÚ
join_ratioÚ num_clients)Úselfr Útimes©Ú __class__© õd D:\京东\promot\第二次投稿\å®�验\æœ�务器\native - pro\system\flcore\servers\serverbabupt.pyr s zFedBABUPT.__init__c
C sÀ g }t | jd ƒD �]>}| ¡ | _| ¡ || j dkrXtd|› d�ƒ tdƒ | ¡ d}| jD ]}| ¡ }|| ¡ }qbtd
|¡ƒ | j |¡ d}t
| jd jj ¡ | jd jj ¡ ƒD ]:\}}|| } t | dk| t | ¡| ¡} |t | ¡ }qÀtd
| ¡ ¡ƒ | j | ¡ ¡ || j dk�rBtdƒ | j|d � | ¡ | ¡ qtd
ƒ tt| jƒƒ td ƒ tt|ƒƒ | jD ]}| ¡ �q„td ƒ | ¡ | ¡ | ¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz"Averaged prompr difference: {:.4f}z"0 and 1 clients difference: {:.4f}z
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.z4
-------------Evaluate fine-tuned model-------------) ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚitemÚformatr ÚappendÚzipÚclientsÚmodelÚ generatorÚ
parametersÚtorchÚwhereÚ
zeros_likeÚsumr Úreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ fine_tuneÚ save_resultsÚsave_global_modelÚsave_client_model)
r Ú local_accÚiÚ
temp_diff_proÚclientÚtemp_diff_pro_clientÚdiverge_clentsÚ new_paramÚ old_paramr r r r r sN
ÿ
zFedBABUPT.trainc C s t j d| jd| jjd | jj d | jj d | jj d | jj d | jj
¡}t j |¡sjt |¡ t
| jƒD ]†\}}t j || jd t|ƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d ¡}t |j|¡ qtd S )NÚmodelsr7 Ú*Ú_clientÚ_z.pt)ÚosÚpathÚjoinÚdatasetr Úarv1Úarv2Úarv3Úarv4Úarv5Úarv6ÚexistsÚmakedirsÚ enumerater$ Ú algorithmÚstrÚ
num_promptr r Ú plocal_stepsr r( Úsaver% )r Ú
model_pathÚc_idxÚcÚmodel_path_saver r r r3 N s T
pzFedBABUPT.save_client_modelc C s€ | j d | j }d| jj d | jj d | jj d | jj d | jj d | jj d }t j
|¡srt |¡ t
| jƒ�r||d | j d t| jƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ d t| jjƒ }|d |¡ }td| ƒ t |d¡�f}|jd| jd � |jd
| j d � |jd | j d � |jd | j d � |jd
| j d � |jd| j d � W 5 Q R X d S )Nr? z ../results/r= ú/z{}.h5z File path: Úwr/ )ÚdataÚrs_test_acc_stdÚ rs_test_aucÚ
rs_train_lossr r )!rC rM r rD rE rF rG rH rI r@ rA rJ rK Úlenr/ ÚgoalrN r rO r r rP r r! r
Úh5pyÚFileÚcreate_datasetrY rZ r[ r r )r ÚalgoÚ result_pathÚ file_pathÚhfr r r r1 V s L
l zFedBABUPT.save_resultsNc C s| | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ} dd„ t|d |d ƒD ƒ}
|d krÎ| j |¡ n
| |¡ | j |¡ | j t | ¡¡ |d k�r| j
|¡ n
| |¡ t d |¡ƒ t d
|¡ƒ t d |¡ƒ t d |¡ƒ t d
t | ¡¡ƒ t d t |
¡¡ƒ d S )Né ç ğ?r é é c S s g | ]\}}|| ‘qS r r ©Ú.0ÚaÚnr r r Ú
<listcomp>r s z&FedBABUPT.evaluate.<locals>.<listcomp>c S s g | ]\}}|| ‘qS r r ri r r r rm s s zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}z$Averaged Test oral Accurancy: {:.4f}zAveraged Test AUC: {:.4f}zStd Test Accurancy: {:.4f}zStd Test AUC: {:.4f})
Ú test_metricsÚ
train_metricsr+ r# r/ r" rZ rY ÚnpÚstdr[ r
r! ) r r ÚlossÚstatsÚ stats_trainÚtest_accÚ test_acc2Útest_aucÚ
train_lossÚaccsÚaucsr r r r i s,
zFedBABUPT.evaluatec C s~ g }g }g }g }| j D ]H}| ¡ \}}}} | |d ¡ | |d ¡ | | | ¡ | |¡ qdd„ | j D ƒ}
|
||||fS )Nrf c S s g | ]
}|j ‘qS r )Úid)rj rT r r r rm • s z*FedBABUPT.test_metrics.<locals>.<listcomp>)r$ rn r" ) r Ú num_samplesÚ tot_correctÚ tot_correct2Útot_aucrT ÚctÚct2ÚnsÚaucÚidsr r r rn ˆ s
zFedBABUPT.test_metricsc C s� t | jƒdkst‚g | _d}g | _g | _| jD ]8}| j |j¡ ||j7 }| j |j¡ | j |j ¡ q.t
| jƒD ]\}}|| | j|< qrd S )Nr ) r\ r ÚAssertionErrorÚuploaded_weightsÚ uploaded_idsÚuploaded_modelsr" Ú
train_samplesr{ r% rL )r Ú tot_samplesr7 r5 rW r r r r, š s
zFedBABUPT.receive_models)NN) Ú__name__Ú
__module__Ú __qualname__r r r3 r1 r rn r, Ú
__classcell__r r r r r
s 4
r )
Zflcore.clients.clientbabuptr Úflcore.servers.serverbaser Ú threadingr r^ Úcopyr@ r( Únumpyrp r r r r r Ú<module> s | 5,957 | Python | .py | 53 | 111.188679 | 497 | 0.427942 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,797 | serverproto.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverproto.cpython-38.pyc | U
•icÊ ã @ sh d dl mZ d dlmZ d dlmZ d dlmZ d dlZd dl Z
d dl m Z G dd„ deƒZ
d d
„ ZdS ) é )Ú clientProto)ÚServer)Úread_client_data)ÚThreadN)Ú defaultdictc s> e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Zd d
d „Z‡ ZS )
ÚFedProtoc sj t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ g | _|j | _ dd„ t
|j ƒD ƒ| _ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.c S s g | ]}d ‘qS )N© )Ú.0Ú_r r õF D:\京东\promot\cifar\cifar\tiny\system\flcore\servers\serverproto.pyÚ
<listcomp> s z%FedProto.__init__.<locals>.<listcomp>) ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clientsÚBudgetÚ num_classesÚrangeÚ
global_protos)ÚselfÚargsÚtimes©Ú __class__r r r s zFedProto.__init__c C s d| _ d}| j sÔt ¡ }| ¡ | _|| j dkrX|dkrXtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ q^| ¡ t | j
ƒ| _ | ¡ | j
t ¡ | ¡ td| j
d ƒ |dkrÊ| j| jg| jd�| _ |d 7 }q
td
ƒ tt| jƒƒ tt| j
d d … ƒt| j
d d … ƒ ƒ | ¡ d S ) NFr z
-------------Round number: z
-------------z
Evaluate global modelz2--------------------------------------------------éÿÿÿÿ)Úacc_lssÚtop_cnté z
Best global accuracy.)ÚdoneÚtimeÚselect_clientsÚselected_clientsÚeval_gapr ÚevaluateÚtrainÚreceive_protosÚproto_aggregationÚuploaded_protosr Ú send_protosr ÚappendÚ
check_doneÚ rs_test_accr ÚmaxÚsumÚlenÚ save_results)r ÚiÚs_tÚclientr r r r' s.
(zFedProto.trainc C s. t | jƒdkst‚| jD ]}| | j¡ qd S ©Nr )r1 ÚclientsÚAssertionErrorZ
set_protosr ©r r5 r r r r+ C s
zFedProto.send_protosc C sJ t | jƒdkst‚g | _g | _| jD ] }| j |j¡ | j |j¡ q$d S r6 )r1 r$ r8 Ú uploaded_idsr* r, ÚidÚprotosr9 r r r r( I s
zFedProto.receive_protosNc C sØ | ¡ }| ¡ }t|d ƒd t|d ƒ }t|d ƒd t|d ƒ }dd„ t|d |d ƒD ƒ}|d krz| j |¡ n
| |¡ |d krš| j |¡ n
| |¡ td |¡ƒ td |¡ƒ td t
|¡¡ƒ d S ) Né g ğ?r c S s g | ]\}}|| ‘qS r r )r ÚaÚnr r r r X s z%FedProto.evaluate.<locals>.<listcomp>zAveraged Train Loss: {:.4f}z Averaged Test Accurancy: {:.4f}zStd Test Accurancy: {:.4f}) Ú test_metricsÚ
train_metricsr0 Úzipr. r, Ú
rs_train_lossr ÚformatÚnpÚstd)r ÚaccÚlossÚstatsÚ stats_trainÚtest_accÚ
train_lossÚaccsr r r r& R s
zFedProto.evaluate)NN) Ú__name__Ú
__module__Ú __qualname__r r' r+ r( r& Ú
__classcell__r r r r r
s
( r c C s– t tƒ}| D ]$}| ¡ D ]}|| || ¡ qq | ¡ D ]V\}}t|ƒdkr‚d|d j }|D ]}||j7 }q`|t|ƒ ||< q:|d j||< q:|S )Nr r )r ÚlistÚkeysr, Úitemsr1 Údata)Zlocal_protos_listZagg_protos_labelZ local_protosÚlabelZ
proto_listÚprotor3 r r r r) k s r) )Zflcore.clients.clientprotor Úflcore.servers.serverbaser Úutils.data_utilsr Ú threadingr r" ÚnumpyrE Ú collectionsr r r) r r r r Ú<module> s a | 3,701 | Python | .py | 33 | 111 | 412 | 0.433361 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,798 | serverrod.cpython-38.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serverrod.cpython-38.pyc | U
ºĞıcÄ ã @ sL d dl mZ d dlmZ d dlmZ d dlmZ d dlZG dd„ deƒZ dS )é )Ú clientROD)ÚServer)Úread_client_data)ÚThreadNc s$ e Zd Z‡ fdd„Zdd„ Z‡ ZS )ÚFedRODc sF t ƒ ||¡ | ¡ | |t¡ td| j› d| j› �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© õW D:\京东\promot\第二次投稿\å®�验\native - pro\system\flcore\servers\serverrod.pyr s
zFedROD.__init__c C sÜ g }t | jd ƒD ]Š}| ¡ | _| ¡ || j dkrVtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ q\|| j dkrŒtdƒ | j|d� | ¡ |
¡ qtdƒ tt | j ƒƒ td ƒ tt |ƒƒ |
¡ | ¡ d S )
Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Evaluate local model)Úaccz
Best global accuracy.z
Best local accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr ÚevaluateÚtrainÚreceive_modelsÚaggregate_parametersÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r Ú local_accÚiÚclientr r r r s*
z FedROD.train)Ú__name__Ú
__module__Ú __qualname__r r Ú
__classcell__r r r r r s
r )
Zflcore.clients.clientrodr Úflcore.servers.serverbaser Úutils.data_utilsr Ú threadingr Útimer r r r r Ú<module> s
| 1,678 | Python | .py | 19 | 87.105263 | 360 | 0.495783 | hkgdifyu/pFedPT | 8 | 3 | 0 | GPL-2.0 | 9/5/2024, 10:48:09 PM (Europe/Amsterdam) |
2,286,799 | serveramp.cpython-39.pyc | hkgdifyu_pFedPT/system/flcore/servers/__pycache__/serveramp.cpython-39.pyc | a
f¾`cÍ ã @ sd d dl Z d dlZd dlZd dlZd dlZd dlmZmZ d dl m
Z
d dl m Z G dd„ de
ƒZ
dS )é N)Ú clientAMPÚweight_flatten)ÚServer)ÚThreadc s4 e Zd Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡ ZS ) ÚFedAMPc sV t ƒ ||¡ | ¡ | |t¡ |j| _|j| _td| j› d| j › �ƒ tdƒ d S )Nz
Join ratio / total clients: z / z%Finished creating server and clients.)
ÚsuperÚ__init__Úset_slow_clientsÚ set_clientsr ÚalphaKÚsigmaÚprintÚ
join_ratioÚ num_clients)ÚselfÚargsÚtimes©Ú __class__© úr/media/sim812/391e55df-b6f2-4fe9-a920-53434a8506fa/lgh/pdept/PFL-Non-IID-master/system/flcore/servers/serveramp.pyr s zFedAMP.__init__c C sš t | jd ƒD ]`}| ¡ | _| ¡ || j dkrRtd|› d�ƒ tdƒ | ¡ | jD ] }| ¡ qX| ¡ qtdƒ tt
| j ƒƒ | ¡ |
¡ d S )Né r z
-------------Round number: z
-------------z
Evaluate global modelz
Best global accuracy.)ÚrangeÚ
global_roundsÚselect_clientsÚselected_clientsÚ send_modelsÚeval_gapr
ÚevaluateÚtrainÚreceive_modelsÚmaxÚ rs_test_accÚ save_resultsÚsave_global_model)r ÚiÚclientr r r r s
z FedAMP.trainc
C sŒ t | jƒdksJ ‚t | jƒdk�rˆ| jD �]\}t | j¡}| ¡ D ]}|j ¡ qBt
| j ¡}t | jƒD ]b\}}|j
| j| krÂt|jƒ}t|ƒ}|| d¡} t | | ¡} | j| | ¡ ||< qhd||< qhdt |¡ }
t | jƒD ]:\}}t| ¡ | ¡ ƒD ] \}} | j|| | 7 _qşqät ¡ } |j�rJt dt tj ¡ ¡ ¡ | ||
¡ |j d d7 < |j d dt ¡ | 7 < q(d S )Nr éÿÿÿÿr gš™™™™™¹?Ú
num_roundsÚ
total_costé ) Úlenr Úuploaded_modelsÚcopyÚdeepcopyÚ global_modelÚ
parametersÚdataÚzero_ÚtorchÚzerosÚ join_clientsÚ enumerateÚidÚ uploaded_idsr ÚmodelÚviewÚdotr ÚeÚsumÚzipÚtimeÚ send_slowÚsleepÚnpÚabsÚrandomÚrandÚset_parametersÚsend_time_cost)
r ÚcÚmuÚparamÚcoefÚjÚmwZ weights_iZ weights_jÚsubZ coef_selfZparam_jÚ
start_timer r r r 6 s2
zFedAMP.send_modelsc C s t | | j ¡| j S )N)ÚmathÚexpr )r Úxr r r r< Z s zFedAMP.e)Ú__name__Ú
__module__Ú __qualname__r r r r< Ú
__classcell__r r r r r s
$r )r3 r- r? ÚnumpyrB rP Zflcore.clients.clientampr r Úflcore.servers.serverbaser Ú threadingr r r r r r Ú<module> s | 2,696 | Python | .py | 26 | 102.5 | 373 | 0.469861 | 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.