Multisig vs Multi input transaction signing Let's say we have a 2 of 2 multisig address that we want to spend from, so the transaction should be signed by both of the private keys.

Now let's say we have a transaction with two inputs, so once again the transaction should be signed by both of the private keys of the inputs.

So how does these two differ in implementation? Even on conceptual level? Are these procedures the same?
They are fairly different things and represent very different use cases. 

Imagine you are the head of the party planning committee and you have two workers (A and B) to help you buy items for the party. You are given 1 bitcoin to fund the party. 

You have two options. 


You can split the funds up between A and B. For example, you could give A and B each 0.5 bitcoins in two separate outputs. If they need to buy something worth more than 0.5 bitcoins, they will need to combine their outputs as inputs to the same transaction. However, for items less than 0.5 bitcoins, A and B will be able to act independently to purchase items (or steal the funds!).
You can jointly give A and B the 1 bitcoin in a 2 of 2 multisig address. Now for any purchase they will need to agree in order to spend from the party committee's funds.


To summarize:

Spending a 2/2 multisig output:

Spends a single previously UTXO and requiring two keys to sign. 

Spending multiple inputs:

Spends multiple previously UTXOs and requires each input to be signed separately. 



With regards to signing these types of transactions, they have to be done slightly differently. 

When signing an input that spends a 2/2 multisig output, the transaction is signed by the two keys and they are encoded into the same scriptSig of the one input. The transaction only becomes valid when both keys have signed with valid signatures.

For example, suppose the scriptPubKey of the previous 2/2 multisig output is:

OP_2 {pubkey1} {pubkey2} OP_2 OP_CHECKMULTISIG


The the scriptSig to spend that output would be:

{pubkey1's signature} {pubkey2's signature}


Notice how they are in the same input's scriptSig.

When signing two different inputs, assuming their previous scriptPubKeys look something like this:

{pubkey1} OP_CHECKSIG


and

{pubkey2} OP_CHECKSIG


Then the two inputs would have scripSigs in this format (respectively):

{pubkey1 signature}


and

{pubkey2 signature}


NOTE: I've used simple scriptPubKey's to be try to be clear about how it generally works, but you should probably use Pay-to-script-hash multisig address and pay-to-pubkey-hash addresses instead of the raw multisig and pay-to-pubkey scriptPubKeys that I used in this example.