def _extractParams(self):
'''open caffe meta information'''
info.resetCaffeProtoModulesvar()
info.CaffeMetaInformation().updateCaffeMetaInformation()
allSolver = info.CaffeMetaInformation().availableSolverTypes()
for solver in allSolver:
self._iterParams(allSolver[solver].parameters())
allLayer = info.CaffeMetaInformation().availableLayerTypes()
for layer in allLayer:
self._iterParams(allLayer[layer].parameters())
def createNewSession(self, transaction):
"""create a new session with SID and PID"""
msg = transaction.asyncRead()
if "pid" in msg and "sid" in msg and "layers" in msg:
layers = msg["layers"]
try:
for layer in layers:
typename = info.CaffeMetaInformation().getLayerType(layer)
except UnknownLayerTypeException as e:
msg["status"] = False
msg["error"] = [e._msg]
logging.error("Could not create session. Unknown layer")
transaction.send(msg)
return
dirp = self._createDirName(msg["sid"])
uid = self._createSession(msg["pid"], dirp)
self.findSessionBySessionUid(uid).setInitialSid(msg["sid"])
msg["status"] = True
msg["uid"] = uid
logging.info("Session created with UID '%s'", uid)
else:
msg["status"] = False
msg["error"] = ["CreateNewSession: No PID or SID provided."]
logging.error("Could not create session. No PID or SID provided.")
transaction.send(msg)
def loadRemoteSession(self, remote, uid):
sid = self.getNextSessionId()
session = ClientSession(self, remote, uid, sid)
availableTypes = info.CaffeMetaInformation().availableLayerTypes()
unknownLayerTypes = []
for layerID in session.state_dictionary["network"]["layers"]:
type = session.state_dictionary["network"]["layers"][layerID][
"parameters"]["type"]
if not type in availableTypes and not type in unknownLayerTypes:
unknownLayerTypes.append(type)
if len(unknownLayerTypes) > 0:
msg = "Cannot load session. The selected session contains layers unknown to the current caffe-version.\n\nUnknown layers:"
for type in unknownLayerTypes:
msg += "\n" + type
msgBox = QMessageBox(QMessageBox.Warning, "Warning", msg)
msgBox.addButton("Ok", QMessageBox.NoRole)
msgBox.exec_()
session._disconnect()
return None
self.__sessions[sid] = session
self.newSession.emit(sid)
return sid
def __parseSettings(self, settings):
if settings:
if "SessionState" in settings:
self.state = settings["SessionState"]
self.__previousState = self.state
if "Iteration" in settings:
self.iteration = settings["Iteration"]
if "solver" in settings:
if "max_iter" in settings["solver"]:
self.max_iter = settings["solver"]["max_iter"]
elif "MaxIter" in settings:
self.max_iter = settings["MaxIter"]
if "LastSnapshot" in settings:
self.last_solverstate = settings["LastSnapshot"]
if "PretrainedWeights" in settings:
self.setPretrainedWeights(settings["PretrainedWeights"])
if "NetworkState" in settings:
self.state_dictionary = settings["NetworkState"]
layers = self.state_dictionary["network"]["layers"]
for id in layers:
if "parameters" in layers[id]:
if "type" in layers[id]["parameters"]:
typename = layers[id]["parameters"]["type"]
layers[id]["type"] = info.CaffeMetaInformation(
).getLayerType(typename)
# layers[id]["type"] = info.CaffeMetaInformation().availableLayerTypes()[typename]
solver = self.state_dictionary["solver"]
if solver:
if "snapshot_prefix" in solver:
self.snapshot_prefix = solver["snapshot_prefix"]
def buildRootInfo(self, name=""):
""" Builds the information about "network" in the state dictionary """
prot = info.CaffeMetaInformation().availableNetParameters().copy()
del prot["layers"]
del prot["layer"]
prot["layers"] = "LayerDict"
prot["layerOrder"] = "LayerOrder"
return self.buildInfo(name,prot,[])
def _addSoftmax(self):
"""Add a softmax layer to the very end of the net, but only if a SoftmaxWithLoss layer was used before."""
# check whether the net used to contain a SoftmaxWithLoss layer
softmaxWithLossWasUsed = False
for id, layer in self._originalNetworkDictionary["layers"].iteritems():
if layer["type"].name() == "SoftmaxWithLoss":
softmaxWithLossWasUsed = True
break
if softmaxWithLossWasUsed:
# ensure that the remaining deployment net has at least one layer
if len(self._deployedNetworkDictionary["layers"]) > 0:
softmaxLayerType = info.CaffeMetaInformation(
).availableLayerTypes()["Softmax"]
# do not add another softmax, if the current deployment network already contains one
softmaxAlreadyIncluded = False
for id, layer in self._deployedNetworkDictionary[
"layers"].iteritems():
if layer["type"].name() == softmaxLayerType.name():
softmaxAlreadyIncluded = True
break
if not softmaxAlreadyIncluded:
# get the very last layer
lastLayerId = self._deployedNetworkDictionary[
"layerOrder"][-1]
lastLayer = self._deployedNetworkDictionary["layers"][
lastLayerId]
# ensure that the determined last layer does have a top blob
if "top" in lastLayer["parameters"] and len(
lastLayer["parameters"]["top"]) > 0:
# create new softmax layer with default values and add it to the deployment net
name = "softmax"
position = len(
self._deployedNetworkDictionary["layers"])
softmaxLayer, softmaxLayerId = self._dHelper.addLayer(
softmaxLayerType, name, position)
# connect the softmax layer with the existing network
softmaxLayer["parameters"]["bottom"] = [
lastLayer["parameters"]["top"][0]
]
# name the output
softmaxLayer["parameters"]["top"] = ["probabilities"]
else:
Log.log(
"Could not add Softmax layer as the very last layer of the deployment net does not have any "
"top blobs.", self._logId)
else:
Log.log(
"Could not add Softmax layer as the remaining deployment net does not have any layers.",
self._logId)
def _load_layers(layerlist):
""" Build the dictionary of all layers in layerlist. The dictionary has the form loadNet needs.
"""
allLayers = info.CaffeMetaInformation().availableLayerTypes()
order = []
res = {}
dicLayerTypeCounter = {}
for layer in allLayers:
dicLayerTypeCounter[layer] = 1
for layer in layerlist:
typename = layer.type
layerinfo = info.CaffeMetaInformation().getLayerType(typename)
id = str(uuid.uuid4())
res[id] = {
"type": layerinfo,
"parameters": _extract_param(layer, layerinfo.parameters())
}
order.append(id)
for id in order:
if "name" not in res[id]["parameters"]:
typeName = res[id]["parameters"]["type"]
newName = typeName + " #" + str(dicLayerTypeCounter[typeName])
changed = True
while changed == True:
newName = typeName + " #" + str(dicLayerTypeCounter[typeName])
changed = False
for id2 in order:
if "name" in res[id2]["parameters"] and res[id2][
"parameters"]["name"] == newName:
dicLayerTypeCounter[typeName] += 1
changed = True
res[id]["parameters"]["name"] = newName
return res, order
def isNetDictValid(netdic):
""" This function returns a tuple (valid, msg). Value is true iff netdic has a valid format.
If the format is not valid, msg contains a text which describes the problem.
"""
if not {"layers", "layerOrder"}.issubset(netdic.keys()):
missing = {"layers", "layerOrder"}.difference(netdic.keys())
return False, "Needed parameters {} not in dictionary".format(
list(missing))
layers = netdic["layers"]
order = netdic["layerOrder"]
#Check if netparameters are valid (except layers)
netparam = info.CaffeMetaInformation().availableNetParameters().copy()
del netparam["layers"]
tmp = netdic.copy()
del tmp["layers"]
del tmp["layerOrder"]
if not _areParameterValid(netparam, tmp):
return False, "Invalid net paremters"
# Check for correct types of this special values
if type(order) != list or type(layers) != dict:
return False, "layerOrder or layers are invalid types"
# Test if all ids are in the layerOrder list and vise versa
if set(layers.keys()) != set(order):
missingOrder = set(layers.keys()).difference(order)
missingLayer = set(order).difference(layers.keys())
return False, "layerOrder and layers does not have same ids - missing ids in layers: {} ; missing ids in order: {}"\
.format(missingLayer, missingOrder)
# Check every sublayer
for id in order:
if not {"parameters", "type"}.issubset(layers[id].keys()):
return False, "parameters or type are not in layers subdictionary"
params = layers[id]["parameters"]
if params is None:
return False, "parameters is None, should be at least {'name': '..', 'type': '...'}"
layer = layers[id]["type"]
if not isinstance(layer, info.LayerType):
return False, "layers is {}, expected instance of protoinfo.LayerType".format(
layer)
validparam, msg = _areParameterValid(layer.parameters(), params)
if not validparam:
return False, "Invalid parameters for {}: {}".format(id, msg)
return True, ""
def _insertInputLayers(self):
"""Insert new input layers with fixed dimensions.
Note that, the number of newly-added input layer might be lower than the number of previously-removed data
layers. On the one hand, we will add only one new input layer for each unique data blob name, while multiple
data layers might have used the same data blob name. On the other hand, input layers will only be added, if
at least one other layer is using the provided data.
"""
inputLayerType = info.CaffeMetaInformation().availableLayerTypes(
)["Input"]
inputLayerNr = 1
for dataBlobName in self._dataBlobNames:
# create a new input layer with default values and add it to the deployment net
name = self._getNewInputLayerName(inputLayerNr)
inputLayer, inputLayerId = self._dHelper.addLayer(
inputLayerType, name, inputLayerNr - 1)
# modify the layer template
inputLayer["parameters"]["top"] = [dataBlobName]
# set input_param.shape with batch size 1 and the dimensions of the first data element
inputLayer["parameters"]["input_param"] = dict()
inputLayer["parameters"]["input_param"]["shape"] = []
inputLayer["parameters"]["input_param"]["shape"].append(dict())
inputLayer["parameters"]["input_param"]["shape"][0][
"dim"] = self._inputBlobShapes[dataBlobName]
inputLayer["parameters"]["input_param"]["shape"][0]["dim"].insert(
0, 1)
# prepare next input layer
inputLayerNr += 1
# check whether there is any shape that could not be determined automatically and needs to be set manually
inputShapeWarning = False
for inputShape in self._inputBlobShapes:
if len(inputShape) < 1:
inputShapeWarning = True
break
if inputShapeWarning:
Log.log(
"At least one input shape could not be determined automatically. Please open the created prototxt "
"and manually fix all input shapes which include only the batch size (1).",
self._logId)
def __init__(self, mainWindow, title):
# Set title and initialize the dock widget
DockElement.__init__(self, mainWindow, title)
self.name = title
widget = QtWidgets.QWidget()
self.layout = QtWidgets.QVBoxLayout()
# Add the text field and the layer list to the widget
self.addDescription()
self.addTextfieldForSearch()
self.addListOfAllLayers()
self.allLayersDict = info.CaffeMetaInformation().availableLayerTypes()
self.allLayers = self.dictionaryToList(self.allLayersDict)
self.setAllLayersNewLayerList(self.allLayers)
widget.setLayout(self.layout)
self.setWidget(widget)
def _bareLayer(layertype, name):
""" Creates a dictionary of the given layertype with the given name
initialized with default values if required.
"""
from backend.caffe.path_loader import PathLoader
proto = PathLoader().importProto()
res = {"type": layertype}
layerParamInst = proto.LayerParameter()
res["parameters"] = _extract_param(
layerParamInst,
info.CaffeMetaInformation().commonParameters())
res["parameters"]["name"] = unicode(name)
layerparamkeys = layertype.layerParamKeys()
for layerparamkey in layerparamkeys:
layerTypeParam = layertype.parameters()[layerparamkey]
layerTypeParamInst = layerTypeParam.protoclass()()
res["parameters"][layerparamkey] = _extract_param(
layerTypeParamInst, layerTypeParam.parameter())
res["parameters"]["type"] = unicode(layertype.name())
return res
def updateListOfAllLayers(self):
info.CaffeMetaInformation().updateCaffeMetaInformation()
self.allLayersDict = info.CaffeMetaInformation().availableLayerTypes()
self.allLayers = self.dictionaryToList(self.allLayersDict)
self.setAllLayersNewLayerList(self.allLayers)
self.updateAllLayersWindowNewList(self.allLayers)
def loadProject(self, set_settings=False):
""" Loads the settings of the project. Returns a state-dictionary for
the NetworkManager.
State looks like: {
"projectid": "xyz...",
"caffeVersion": {...},
"inputdb": { .. },
"network": { .. },
"solver": {...},
"selection": [],
"position": {}
}
"""
filename = self.projectConfigFileName()
projectData = None
if not os.path.exists(filename):
self.__loadDefaultSettings()
self.projectId = str(uuid.uuid4())
sessionID = self.createSession(state_dictionary=None)
self.setActiveSID(sessionID)
else:
with open(filename, "r") as file:
res = json.load(file)
if set_settings and ("environment" in res):
self.settings = res["environment"]
if "inputdb" in res:
self.__inputManagerState = res["inputdb"]
if "caffeVersion" in res:
self.caffeVersion = res["caffeVersion"]
caffeVersions.setDefaultVersion(self.caffeVersion)
if "projectdata" in res: # this is for backward compatibility, only
# Fill missing type-instances
allLayers = info.CaffeMetaInformation().availableLayerTypes()
layers = res["projectdata"]["network"]["layers"]
for id in layers:
typename = layers[id]["parameters"]["type"]
layers[id]["type"] = allLayers[typename]
projectData = res["projectdata"]
if "transform" in res:
self.__transform = res["transform"]
if "projectid" in res:
self.projectId = res["projectid"]
else:
self.projectId = str(uuid.uuid4()) # backwards compatibility
self.loadSessions()
if len(self.__sessions) == 0:
Log.error(
"Could not find a valid Session, creating new empty Session. Maybe the project "
"contains only remote Sessions?", self.getCallerId())
sessionID = self.createSession()
#check which session was last active, if this is not available, take the last Session in SID order, if no
# valid sessions are available, create a new empty session and set this active
if "activeSession" in res:
self.setActiveSID(res["activeSession"])
elif len(self.getValidSIDs()) > 0:
self.setActiveSID(self.getValidSIDs()[-1])
else: # this branch should be reached only if an old projekt format is opened, where no sessions are stored
sessionID = self.createSession(state_dictionary=projectData)
self.setActiveSID(sessionID)
if projectData:
self.setActiveSessionStateDict(projectData)
if self.getActiveSession().hasStateDict():
projectData = self.getActiveSession().state_dictionary
else:
if projectData:
# this branch should be reached only if an old projekt format is opened,
# where sessions do not have their own state dictionary
self.setActiveSessionStateDict(projectData)
return projectData, self.__inputManagerState, self.__transform
def enumOptions(self):
if self.uri == ["type"]:
return info.CaffeMetaInformation().availableSolverTypes()
return super(PropertyInfo, self).enumOptions()