高性能服务器(windows IOCP)

最新推荐文章于 2021-08-07 18:31:00 发布
最新推荐文章于 2021-08-07 18:31:00 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： 3.5通信服务

转载

http://blog.csdn.net/guestcode

/********************************************************************************
* *
* GSocket：完成端口通讯模块（IOCP Socket） *
* ——GTcpServer *
* *
* Copyright © 2009 代码客（卢益贵） 版权所有 *
* 未经许可，不得用于任何项目开发 *
* QQ:48092788 E-Mail:gcode@qq.com 源码博客：http://blog.csdn.net/guestcode *
* *
* GSN:34674B4D-1F63-11D3-B64C-11C04F79498E *
********************************************************************************/

#include "stdafx.h"
#include <winsock2.h>
#include <mswsock.h>

#include "GLog.h"
#include "GMemory.h"
#include "GWorkerThread.h"
#include "GPerIoData.h"
#include "GPerHandleData.h"
#include "GSocketInside.h"
#include "GThread.h"
#include "GSocket.h"

#if(_GSOCKET_FUNC_TCP_SERVER)

#define GTcpSvr_AcceptEx(pListener, pClient, pIoData) (pfnGSockAcceptEx(pListener->Socket, pClient->Socket, pIoData->cData, dwGSockAcceptBytes, sizeof(SOCKADDR_IN) + 16, sizeof(SOCKADDR_IN) + 16, NULL, LPWSAOVERLAPPED(pIoData)))
#define GTcpSvr_GetAcceptExSockAddrs(pListener, Buf, Bytes, Addr, Len) (pfnGSockGetAcceptExSockAddrs(Buf, Bytes, sizeof(SOCKADDR_IN) + 16, sizeof(SOCKADDR_IN) + 16, (PSOCKADDR *)&Addr, (int*)&Len, (PSOCKADDR *)&Addr, (int*)&Len))
#define GTcpSvr_DisconnectEx(pClient) (pfnGSockDisconnectEx(pClient->Socket, NULL, TF_REUSE_SOCKET, 0))

/*********************************************************************************
变量定义和初始化
*********************************************************************************/
#if(_USE_INTERLOCKED_IN_LIST)
BOOL bGTcpSvrPendingAcceptLock = FALSE;
#else
CRITICAL_SECTION GTcpSvrPendingAcceptCS;
#endif
PGHND_DATA pGTcpSvrPendingAcceptHead = NULL;
DWORD dwGTcpSvrPendingAcceptCount = 0;

#if(_USE_INTERLOCKED_IN_LIST)
BOOL bGTcpSvrClientLock = FALSE;
#else
CRITICAL_SECTION GTcpSvrClientCS;
#endif
PGHND_DATA pGTcpSvrClientHead = NULL;
DWORD dwGTcpSvrClientCount = NULL;

CRITICAL_SECTION GTcpSvrListenerCS;
DWORD dwGTcpSvrListenerCount = 0;
PGHND_DATA pGTcpSvrListeners[WSA_MAXIMUM_WAIT_EVENTS];
HANDLE hGTcpSvrListenerEvents[WSA_MAXIMUM_WAIT_EVENTS];
PGHND_DATA* pGTcpSvrOvertimeClient = NULL;
DWORD pGTcpSvrOvertimeCount = 0;
GTHREAD GTcpSvrServiceThreadData;

BOOL bGTcpSvrIsActive = FALSE;

/*********************************************************************************
内核锁
*********************************************************************************/
#if(_USE_INTERLOCKED_IN_LIST)
void GTcpSvr_LockClientList(void)
{
for(;;)
{
if(FALSE == GSock_InterlockedSet(bGTcpSvrClientLock, TRUE, FALSE))
return;
}
}

void GTcpSvr_UnlockClientList(void)
{
GSock_InterlockedSet(bGTcpSvrClientLock, FALSE, TRUE);
}

void GTcpSvr_LockPendingAcceptList(void)
{
for(;;)
{
if(FALSE == GSock_InterlockedSet(bGTcpSvrPendingAcceptLock, TRUE, FALSE))
return;
}
}

void GTcpSvr_UnlockPendingAcceptList(void)
{
GSock_InterlockedSet(bGTcpSvrPendingAcceptLock, FALSE, TRUE);
}
#endif

/*********************************************************************************
变量设置
*********************************************************************************/
DWORD GTcpSvr_GetClientCount(void)
{
return(dwGTcpSvrClientCount);
}

DWORD GTcpSvr_GetListenerCount(void)
{
return(dwGTcpSvrListenerCount);
}

DWORD GTcpSvr_GetPendingAcceptCount(void)
{
return(dwGTcpSvrPendingAcceptCount);
}

/*********************************************************************************
Listener参数获取
*********************************************************************************/
DWORD GTcpSvr_GetListenerConnectCount(DWORD dwListenerId)
{
return((DWORD)PGHND_DATA(dwListenerId)->pData);
}

void GTcpSvr_TraversalListener(DWORD dwParam, PFN_ON_GSOCK_TRAVERSAL pfnOnProc)
{
if(!bGTcpSvrIsActive)
return;

EnterCriticalSection(&GTcpSvrListenerCS);

DWORD i;

for(i = 0; i < dwGTcpSvrListenerCount; i++)
{
if(!pfnOnProc(dwParam, i, DWORD(pGTcpSvrListeners[i])))
break;
}

LeaveCriticalSection(&GTcpSvrListenerCS);
}

/*********************************************************************************
服务操作
*********************************************************************************/
void GTcpSvr_InsertClientList(PGHND_DATA pClient)
{
#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_LockClientList();
#else
EnterCriticalSection(&GTcpSvrClientCS);
#endif

pClient->pPrior = NULL;
pClient->pNext = pGTcpSvrClientHead;
if(pGTcpSvrClientHead)
pGTcpSvrClientHead->pPrior = pClient;
pGTcpSvrClientHead = pClient;
dwGTcpSvrClientCount++;
#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_UnlockClientList();
#else
LeaveCriticalSection(&GTcpSvrClientCS);
#endif
}

void GTcpSvr_DeleteClientList(PGHND_DATA pClient)
{
#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_LockClientList();
#else
EnterCriticalSection(&GTcpSvrClientCS);
#endif

if(pClient == pGTcpSvrClientHead)
{
pGTcpSvrClientHead = pGTcpSvrClientHead->pNext;
if(pGTcpSvrClientHead)
pGTcpSvrClientHead->pPrior = NULL;
}else
{
pClient->pPrior->pNext = pClient->pNext;
if(pClient->pNext)
pClient->pNext->pPrior = pClient->pPrior;
}
dwGTcpSvrClientCount--;

#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_UnlockClientList();
#else
LeaveCriticalSection(&GTcpSvrClientCS);
#endif
}

void GTcpSvr_InsertPendingAcceptList(PGHND_DATA pClient)
{
#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_LockPendingAcceptList();
#else
EnterCriticalSection(&GTcpSvrPendingAcceptCS);
#endif

pClient->pNext = pGTcpSvrPendingAcceptHead;
if(pGTcpSvrPendingAcceptHead)
pGTcpSvrPendingAcceptHead->pPrior = pClient;
pClient->pPrior = NULL;
pGTcpSvrPendingAcceptHead = pClient;
dwGTcpSvrPendingAcceptCount++;

#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_UnlockPendingAcceptList();
#else
LeaveCriticalSection(&GTcpSvrPendingAcceptCS);
#endif
}
void GTcpSvr_DeletePendingAcceptList(PGHND_DATA pClient)
{
#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_LockPendingAcceptList();
#else
EnterCriticalSection(&GTcpSvrPendingAcceptCS);
#endif

if(pClient == pGTcpSvrPendingAcceptHead)
{
pGTcpSvrPendingAcceptHead = pGTcpSvrPendingAcceptHead->pNext;
if(pGTcpSvrPendingAcceptHead)
pGTcpSvrPendingAcceptHead->pPrior = NULL;
}else
{
pClient->pPrior->pNext = pClient->pNext;
if(pClient->pNext)
pClient->pNext->pPrior = pClient->pPrior;
}
dwGTcpSvrPendingAcceptCount--;

#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_UnlockPendingAcceptList();
#else
LeaveCriticalSection(&GTcpSvrPendingAcceptCS);
#endif
}

void GTcpSvr_TraversalClient(DWORD dwParam, DWORD dwFromIndex, DWORD dwCount, PFN_ON_GSOCK_TRAVERSAL pfnOnProc)
{
if(!bGTcpSvrIsActive)
return;

#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_LockClientList();
#else
EnterCriticalSection(&GTcpSvrClientCS);
#endif

PGHND_DATA pClient;
DWORD dwIndex;

dwIndex = 0;
dwCount = dwFromIndex + dwCount;
pClient = pGTcpSvrClientHead;
while(pClient)
{
if(dwIndex >= dwFromIndex)
{
if((dwIndex >= dwCount) || (!pfnOnProc(dwParam, dwIndex, (DWORD)pClient)))
break;
}
dwIndex++;
pClient = pClient->pNext;
}

#if(_USE_INTERLOCKED_IN_LIST)
GTcpSvr_UnlockClientList();
#else
LeaveCriticalSection(&GTcpSvrClientCS);
#endif
}
免费领取CSDN积分大礼包
对我有用[0] 丢个板砖[0] 引用 | 举报 | 管理

GuestCode
GuestCode
等级： #2 得分：0
回复于： 2009-09-21 12:00:25
void GTcpSvr_OnReadWriteError(PGHND_DATA pClient, PGIO_DATA pIoData)
{
if(GIO_WRITE_COMPLETED == pIoData->OperType)
pfnOnGSockSendErrorSvr((DWORD)pClient, pIoData->cData, pIoData->WSABuf.len);
GIoDat_Free(pIoData);

if(GHND_STATE_CONNECTED != GSock_InterlockedSet(pClient->hsState, GHND_STATE_DISCONNECT, GHND_STATE_CONNECTED))
return;

GTcpSvr_DeleteClientList(pClient);
GSock_InterlockedDec(PGHND_DATA(pClient->pOwner)->pData);
pfnOnGSockDisconnectSvr((DWORD)pClient);

if(GIO_CONNECTION_OVERFLOW == pIoData->OperType)
{
pfnOnGSockConnectionOverflow((DWORD)pClient);
GSock_UninitTcpHndData(pClient);
#if(_REUSED_SOCKET)
GSock_InitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
}else
if(GIO_IDLE_OVERTIME == pIoData->OperType)
{
pfnOnGSockIdleOvertime((DWORD)pClient);
GSock_UninitTcpHndData(pClient);
#if(_REUSED_SOCKET)
GSock_InitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
}else
if(GIO_CLOSE == pIoData->OperType)
{
GSock_UninitTcpHndData(pClient);
#if(_REUSED_SOCKET)
GSock_InitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
}else
{
#if(_REUSED_SOCKET)
GTcpSvr_DisconnectEx(pClient);
#else
GSock_UninitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
}

}

void GTcpSvr_OnReadWrite(DWORD dwBytes, PGHND_DATA pClient, PGIO_DATA pIoData)
{
if(!dwBytes)
{
if(bGSockIsZeroByteRecv && (GHND_STATE_CONNECTED == pClient->hsState) && (GIO_READ_COMPLETED == pIoData->OperType))
{
GIoDat_ResetIoDataOnRead(pIoData);
pIoData->OperType = GIO_ZERO_READ_COMPLETED;
pIoData->WSABuf.len = dwGBufSize;
dwBytes = 0;
DWORD dwFlag = 0;
if((SOCKET_ERROR != WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) ||
(ERROR_IO_PENDING == WSAGetLastError()))
{
return;
}
}
GTcpSvr_OnReadWriteError(pClient, pIoData);
return;
}

if(GIO_WRITE_COMPLETED == pIoData->OperType)
{
pfnOnGSockSendedSvr((DWORD)pClient, pIoData->cData, dwBytes);
GIoDat_Free(pIoData);
}else
{
pClient->dwTickCountAcitve = GetTickCount();
#if(_USE_GPROTOCOL)
if(GCommProt_ProcessReceive(pClient, pIoData->cData, dwBytes, pfnOnGSockReceiveSvr))
{
pIoData = GIoDat_Alloc();
if(!pIoData)
{
GLog_Write("GTcpSvr_OnReadWrite：IoData分配失败，无法再投递接收");
return;
}
}
#else
pfnOnGSockReceiveSvr((DWORD)pClient, pIoData->cData, dwBytes);
#endif

GIoDat_ResetIoDataOnRead(pIoData);
pIoData->OperType = GIO_READ_COMPLETED;
pIoData->WSABuf.len = dwGSockRecvBytes;
dwBytes = 0;
DWORD dwFlag = 0;
if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) &&
(ERROR_IO_PENDING != WSAGetLastError()))
{
GTcpSvr_OnReadWriteError(pClient, pIoData);
}
}
}

BOOL GTcpSvr_PostAccept(PGHND_DATA pListener, DWORD dwCount)
{
int nCount;
PGHND_DATA pClient;
PGIO_DATA pIoData;

nCount = 0;

while(dwCount && (dwGTcpSvrClientCount + dwGTcpSvrPendingAcceptCount < dwGSockMaxNumberConnection))
{
pClient = GHndDat_Alloc();
if(!pClient)
{
GLog_Write("GTcpSvr_PostAccept：分配HndData失败，无法投递接受");
return(nCount);
}
#if(!_REUSED_SOCKET)
GSock_InitTcpHndData(pClient);
#endif
pIoData = GIoDat_Alloc();
if(!pIoData)
{
#if(!_REUSED_SOCKET)
GSock_UninitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
GLog_Write("GTcpSvr_PostAccept：分配IoData失败，无法投递接受");
return(nCount);
}

pClient->pfnOnIocpOper = &GTcpSvr_OnReadWrite;
pClient->pfnOnIocpError = &GTcpSvr_OnReadWriteError;
pClient->htType = GHND_TYPE_TCP_SVR_CLIENT;
pClient->hsState = GHND_STATE_ACCEPTING;
pClient->pOwner = pListener;
pClient->pData = NULL;

pIoData->OperType = GIO_CONNECTED;
pIoData->pOwner = pClient;
pIoData->WSABuf.len = dwGSockRecvBytes;

GTcpSvr_InsertPendingAcceptList(pClient);
if((!GTcpSvr_AcceptEx(pListener, pClient, pIoData)) && (ERROR_IO_PENDING != WSAGetLastError()))
{
GTcpSvr_DeletePendingAcceptList(pClient);
GIoDat_Free(pIoData);
#if(!_REUSED_SOCKET)
GSock_UninitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
GLog_Write("GTcpSvr_PostAccept：执行pfnGTcpSvrAcceptEx失败，无法投递接受");
return(nCount);
}
dwCount--;
nCount++;
}//for(i = 0; i < dwCount; i++)

return(TRUE);
}

void GTcpSvr_OnAcceptError(PGHND_DATA pListener, PGIO_DATA pIoData)
{
PGHND_DATA pClient = PGHND_DATA(pIoData->pOwner);
GIoDat_Free(pIoData);

if(GHND_STATE_ACCEPTING != GSock_InterlockedSet(pClient->hsState, GHND_STATE_DISCONNECT, GHND_STATE_ACCEPTING))
return;

GTcpSvr_DeletePendingAcceptList(pClient);
if(GIO_CLOSE == pIoData->OperType)
{
GSock_UninitTcpHndData(pClient);
GHndDat_Free(pClient);
}else
{
#if(_REUSED_SOCKET)
GTcpSvr_DisconnectEx(pClient);
#else
GSock_UninitTcpHndData(pClient);
#endif
GHndDat_Free(pClient);
}
}

void GTcpSvr_OnAccept(DWORD dwBytes, PGHND_DATA pListener, PGIO_DATA pIoData)
{
if((!dwBytes) && (dwGSockAcceptBytes))
{
GTcpSvr_OnAcceptError(pListener, pIoData);
return;
}

PGHND_DATA pClient;
PSOCKADDR_IN pAddr;
int nLen;

pClient = PGHND_DATA(pIoData->pOwner);
GTcpSvr_DeletePendingAcceptList(pClient);
setsockopt(pClient->Socket, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char *)&(pListener->Socket), sizeof(pListener->Socket));
BOOL bDontLinger = FALSE;
setsockopt(pClient->Socket, SOL_SOCKET, SO_DONTLINGER, (const char *) &bDontLinger, sizeof(BOOL));

GTcpSvr_GetAcceptExSockAddrs(pListener, pIoData->cData, dwGSockAcceptBytes, pAddr, nLen);
pClient->dwAddr = pAddr->sin_addr.S_un.S_addr;
pClient->dwPort = htons(pAddr->sin_port);
pClient->hsState = GHND_STATE_CONNECTED;
pClient->dwTickCountAcitve = GetTickCount();

GTcpSvr_InsertClientList(pClient);
GSock_InterlockedAdd(PGHND_DATA(pClient->pOwner)->pData);
#if(_USE_GPROTOCOL)
if(GCommProt_ProcessReceive(pClient, pIoData->cData, dwBytes, pfnOnGSockConnectTcpSvr))
{
pIoData = GIoDat_Alloc();
if(!pIoData)
{
GLog_Write("GTcpSvr_OnAccept：IoData分配失败，连接后无法再投递接收");
return;
}
}
#else
pfnOnGSockConnectTcpSvr((DWORD)pClient, pIoData->cData, dwBytes);
#endif

ZeroMemory(pIoData, sizeof(WSAOVERLAPPED));
DWORD dwCount = dwGSockNumberPostRecv;
for(;;)
{
GIoDat_ResetIoDataOnRead(pIoData);
pIoData->OperType = GIO_READ_COMPLETED;
pIoData->WSABuf.len = dwGSockRecvBytes;
dwBytes = 0;
DWORD dwFlag = 0;
if((SOCKET_ERROR == WSARecv(pClient->Socket, &(pIoData->WSABuf), 1, &dwBytes, &dwFlag, LPWSAOVERLAPPED(pIoData), NULL)) &&
(ERROR_IO_PENDING != WSAGetLastError()))
{
GTcpSvr_OnReadWriteError(pClient, pIoData);
break;
}
dwCount--;
if(!dwCount)
break;
pIoData = GIoDat_Alloc();
if(!pIoData)
{
GLog_Write("GTcpSvr_OnAccept：申请IoData失败，连接后无法投递接收");
break;
}
pIoData->pOwner = pClient;
}
if(dwGTcpSvrClientCount >= dwGSockMaxNumberConnection)
{
pfnOnGSockConnectionOverflow((DWORD)pClient);
void GTcpSvr_DoCloseClient(PGHND_DATA pClient, PGHND_DATA pIoDataOwner, GIO_OPER_TYPE OperType);
GTcpSvr_DoCloseClient(pClient, pClient, GIO_CLOSE);
GLog_Write("GTcpSvr_OnAccept：连接超过最大值");
}
}

 

 

 

TensorFlow用softmax_cross_entropy_with_logits的loss一直增大
_Hope_
11-28 344
因为softmax_cross_entropy_with_logits传入的labels要是one-hot的， labels和logits的shape相同 转化方法： labels_onehot = tf.one_hot(input_y, num_classes) input_y是[batch_size]的shape ...
ABPR: 利用对抗训练技术增强的BPR
张小磊的博客
07-15 483
正值毕业季，送给大家一首毛毛的《入海》。希望大家跃入人海，各有风雨灿烂(✪ω✪)前言相信大家对于经典的成对学习(Pairwise Learning)方式的推荐模型BPR[1](Bayes...
tensorflow训练过程中loss越来越大
Focus
08-13 4927
在学习Tensorflow的时候，发现训练时loss竟然越来越大，多次检查之后发现代码并无问题。最终发现原因是学习率太大，调小之后loss减小，特此记录。
训练损失增大
weixin_42764932的博客
03-05 1497
学习率过大 学习率太大，学下不去 梯度忘清零 optimizer.zero_grad() 正则化过度 L1 L2和Dropout是防止过拟合用的，当训练集loss下不来时，就要考虑一下是不是正则化过度，导致模型欠拟合了。一般在刚开始是不需要加正则化的，过拟合后，再根据训练情况进行调整。如果一开始就正则化，那么就难以确定当前的模型结构设计是否正确了，而且调试起来也更加困难。 https://blog.csdn.net/dl962454/article/details/109624917?utm_mediu
训练损失越来越大_无需contrastive学习，微软亚研提基于实例分类无监督预训练方法...
weixin_39717704的博客
12-03 172
机器之心发布机器之心编辑部在本文中，微软亚洲研究院的研究员和实习生们提出了一个简单且高效的无监督预训练方法——参数化实例分类(PIC)。和目前最常用的非参数化对比学习方法不同，PIC 采用了类似于有监督图片分类的框架，将每个实例或图片看作一个独立的类别进行实例分类从而进行无监督学习。与 SimCLR 或 MoCo 这类方法相比，PIC 不需要处理潜在的信息泄漏问题，因此结构简单直观。研究者在实验中...
解决Keras下训练CNN模型时，Loss值不断增大问题
人生海海
10-24 8848
背景 在服务器上训练用keras写的Lenet5的cnn分类模型过程中，发现训练一开始训练的loss值、测试的loss值都在不断增大。如下图：（值大到吐血） 于是乎，开始心酸找错历程（暴哭） 解决过程 1.通常先查看数据集。图像和标签是否对应。没问题（√） 2.模型结构问题，特别是最后输出时种类个数对不对。没问题（√） 3.权重初始化问题。训练之前模型自动初始化。没问题（√） 4.选择合适的激...
eat-offer:以问题为主，专注于面经（主要是推荐系统，机器学习，并行计算，逐步）
03-11
美食优惠个人笔记+面经专注于数据科学（推荐系统，机器学习，并行计算，预期） 所有面经都在持续，迭代更新中... 面经Mysql 01基础架构 02日志系统 03事务隔离 面经并发 01线程 02管程 03内存 04无锁 05不可...
备份还原(SyncBackSE) v9.3.4.0官方版
11-09
SyncBackSE是一款备受推崇的备份和同步工具，其最新版本为v9.3.4.0官方版。这款软件提供了一整套完善的解决方案，旨在帮助用户保护重要数据，确保在面临意外情况时能够轻松恢复。无论是本地硬盘、网络驱动器、FTP...
Social Recommendation with Strong and Weak Ties 学习笔记
ciecus_csdn的博客
11-28 1880
Social Recommendation with Strong and Weak Ties 学习笔记摘要介绍2 相关工作 摘要 随着在线社交网络的爆炸式增长，人们已经广泛的意识到社交信息对推荐系统是非常有用的。社交推荐方法能够很好的应对冷启动问题，因此可以大幅度提升预测准确性。凭借直觉，我们还可以得知，在社交关系的影响下，用户很容易和他们朋友消费过的东西建立联系。尽管已经有很多人研究社交推荐，...
训练损失越来越大_Auto Seg-Loss: 自动损失函数设计
weixin_39989033的博客
11-26 825
前段时间，有一则新闻比较火：全国游泳冠军赛引发争议，傅园慧等五位预赛排名第一的名将因体能测试分数低而无缘决赛傅园慧预赛第一无缘决赛，击剑、体操等比赛也出现类似情况，反映了哪些问题？体能决定运动员赛事成绩合理吗？​www.zhihu.com体能水平可以反映竞技水平吗？对于普通人来说，体能水平和单项的比赛能力大多存在正相关关系。然而，高水平运动员需要的是对特定项目的针对性训练，更高的体能水平并不意味着...
LibRec:一个领先的推荐系统Java库
08-08
它实现了一套最先进的推荐算法，旨在解决两个经典推荐任务：评级预测和项目排名。
训练损失越来越大_性能大幅提升！MindSpore进行量化感知训练详解
weixin_39634876的博客
11-30 821
前言：为了测试量化性能，我们对MindSpore的FakeQuantWithMinMax算子和TensorFlow的fake_quant_with_min_max_args算子在GPU环境下对典型shape的Tensor的量化性能进行了对比测试，结果如下图所示。结果显示，在Tensor规模较小时（Tensor中元素数量级不大于1E+6），MindSpore在GPU上的量化耗时相较于TensorFl...
【卷积神经网络】针对训练过程中Loss突然变大问题的思考
热门推荐
安静
06-03 2万+
在神经网络的训练过程中，正常情况下整体的过程是一个Loss不断下降的过程，然而在训练过程中往往存在一些batch_size输入时，前向传播得到的Loss突然变大的情景。 在训练神经网络过程中，经过softmax函数输出概率后，当当前最大概率对应的类别与训练标签一致时，损失Loss往往较小，而经过softmax输出时，训练标签所对应的概率softmax概率较小，此时的Loss计算结果往往很大。对此...
caffe 训练center loss 太大
learning notes
07-07 1298
在用MsCeleb1M数据集来做人脸识别时，使用center loss损失函数，初始的loss都特别大， center loss 很快就nan了，softmaxloss也很快87.3365了， 只能调小center loss 的比例，从自带的0.008降低到0.0001，才可以，可是收敛时的Loss也特别大。 在loss为nan之后，居然还能继续下降，
采用梯度下降法训练，逻辑回归模型时，loss越来越大，怎么回事？
Kp0fS的草稿纸
08-07 1728
坑
前端累加nan怎么解决_训练网络loss出现Nan解决办法
weixin_39876595的博客
12-04 2332
训练网络loss出现Nan解决办法一.原因一般来说，出现NaN有以下几种情况：1.如果在迭代的100轮以内，出现NaN，一般情况下的原因是因为你的学习率过高，需要降低学习率。可以不断降低学习率直至不出现NaN为止，一般来说低于现有学习率1-10倍即可。2.如果当前的网络是类似于RNN的循环神经网络的话，出现NaN可能是因为梯度爆炸的原因，一个有效的方式是增加“gradient clipping”（...
dqn系列梳理_强化学习--从DQN到PPO， 流程详解
weixin_42099858的博客
12-28 1359
说在前面本文只讲述强化学习常见算法的实现流程， 不涉及原理推倒， 原理上的东西， 推荐看李宏毅老师的强化学习课程。本文包括:Nature DQN, Double DQN, Prioritized Replay DQN, Dueling DQN, Policy Gradient, Actor-Critic, DDPG, PPO算法的流程。本文流程是基于莫凡的RL代码进行梳理。(建议同时打开两个页面，...
深度强化学习之DQN实战
CristianoC
07-21 1475
今天我们会将我们上一篇文章讲解的DQN的理论进行实战，实战的背景目前仍然是探险者上天堂游戏，不过在下一次开始我们会使用OpenAI gym的环境库，玩任何我们想玩的游戏。 算法公式 看上去整个算法似乎很复杂，其实就是Q-Learning的框架加了三样东西 experience replay（经验池） 神经网络计算Q值 暂时冻结q_target参数 接下来我们就一步步把上篇文章学习到的理论实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值