The mnemonic (assembly instruction) is merely a
representation of the binary sequence that is read by the instruction decoder.
When an instruction is fetched, the instruction decoder, a portion of the execution unit, reads the instruction off the operand, which is the whole multi-byte segment in memory.
For x86 architectures, the instruction is composed of 4 bytes (32 bits) and has the following structure.
For example, in the 32 bits allotted to an operand, the most significant 5-8 bits form the actual instruction, such as ADD, JMP, or MOV. The other bit allotments in the first byte are usually specific flag bits that signal the various varieties of that instruction.
The second byte of the instruction is usually register information, such as the register of the source/destination, and flags that signal whether the data is immediate or normal priority, as well as whether the data should be treated as a number or word. The second byte in some instructions can be interchanged for data.
Bytes 3 and 4 are usually data, and if they aren't data, they usually are not present.
What happens is the assembler is very rudimentary - that is, all it does is go down the list of code, and ignoring comments, takes each line of instruction and converts it to its binary counterpart. It would not be conceptually difficult for even a moderately skilled programmer to write a basic assembler provided they had the knowledge of the opcodes. There is no "conversion" per se - the instructions translate literally. There is no black box here, nothing assumed by the assembler. Every line you type is what you get. Each instruction you write corresponds exactly to one instruction cycle, unless you use jump branching to form a loop.