MATL, 7 characters

Btnwdz/

Try it online!

Explanation

B    % Convert to binary

t    % Duplicate

n    % Number of elements

w    % Swap

d    % Consecutive differences

z    % Number of nonzeros

/    % Divide

Japt, 8 bytes

NULL for infinity

¤Ê/¢ä¦ x

Try it online!

Jelly, 8 bytes, score 8

_{Maybe there is a terser way... edit: I don't think there is.}

BL÷BITLƲ

Infinity is given as inf.

Try it online!

...other 8's are possible too, for example BµITL÷@L or BL÷BnƝSƊ.

05AB1E, 8 bytes/characters

bgIbγg</

Try it online or verify all test cases.

Or alternatively:

b©g®¥ÄO/

Try it online or verify all test cases.

Outputs 0.0 for the INF cases.

With both bonuses score: 11.97 (18 bytes/characters * 0.95 * 0.7):

εbgybγg</3.ò}DÆ.±)

Outputs 1 if the first input is larger than the second; -1 if vice-versa; 0 if they are equal.

NOTE: Because I output 0.0 for the INF cases, they are considered lower than non-infinity test cases. Let me know if this has to be fixed..

Try it online.

Explanation:

ε       # Map both values of the (implicit) input-list:

 b      #  Get the binary-string of the current value

  g     #  And get the length of this string

 yb     #  Get the binary-string of the current value again

   γ    #  Split it into chunks of equal adjacent digits

    g<  #  Get the amount of chunks, and subtract 1

 /      #  Divide both numbers

 3.ò    #  Round the number to 3 decimal values

}D      # After the map: duplicate the resulting list

  Æ     # Reduce the duplicated list by subtraction

   .±   # And get the sign of that result

     )  # Then wrap it into a list with the mapped values

        # (and output the result implicitly)

JavaScript (ES6),  46 44  40 bytes / characters

Returns Infinity if there's no bit flip.

n=>(g=s=>n&&1+g(x=s-(n^(n>>=1))%2))``/~x

Try it online!

Commented

n => (                  // n = input integer

  g = s =>              // g = recursive function taking the number s of bit switches

    n &&                //   stop if n is equal to 0

    1 +                 //   otherwise, add 1 to the final returned value

    g(                  //   and do a recursive call to g:

      x =               //     update s and save the result in x:

        s -             //       subtract 1 from s if ...

        (n ^ (n >>= 1)) //       ... there is a bit switch; and shift n to the right

        % 2             //       NB: an extra bit switch is counted on the last bit

    )                   //   end of recursive call

)``                     // initial call to g with s = [''], which is coerced to 0

                        // as soon as something is subtracted from it

/ ~x                    // divide the result of g by -(x + 1), which compensates for

                        // the extra switch

Kotlin, 83 82 bytes

{s->s.toString(2).run{length.toFloat()/(0..length-2).count{this[it]!=this[it+1]}}}

Try it online!

R, 56 bytes

length(y<-(x=scan())%/%2^(0:log2(x))%%2)/sum(diff(y)!=0)

Try it online!

Charcoal, 24 characters

≔⍘Ｎ²θ≔⁺№θ10№θ01η¿ηＩ∕Ｌθη∞

Try it online! Link is to verbose version of code. Explanation:

≔⍘Ｎ²θ

Input the number and convert it to base 2 as a string.

≔⁺№θ10№θ01η

Calculate the number of of switches by counting the occurrences of 10 or 01 in the string.

¿ηＩ∕Ｌθη∞

If the total is nonzero then output the smoothness otherwise print Infinity.

1. Python 3, 131 bytes (154 with file header)

Hi. I know that my code is way longer than others, but I will try it ;) Indentation by tabs.

Script takes sequence of numbers in aguments and prints "smoothness" for each argument on own line. If number of changes is 0, prints "inf".

$ ./script.py 12

4.0



$ ./script.py 12 5 6

4.0

1.5

3.0



$ ./script.py `seq 5`

None

2.0

None

3.0

1.5

file header

#!/usr/bin/env python3

code

import sys

for n in sys.argv[1:]:

    b=bin(int(n))[2:];c=0;l=b[0]

    for o in b:

        if o!=l:c+=1

        l=o

    print(len(b)/c if c>0 else"inf")

Input single number from STDIN: 102+23 bytes (code + file header)

n=input();b=bin(int(n))[2:];c=0;l=b[0]

for o in b:

    if o!=l:c+=1

    l=o

print(len(b)/c if c>0 else"inf")

Ruby, 42 bytes

->n{1.0*(w=(n^n/2).digits 2).size/~-w.sum}

Try it online!

How?

First step: bitwise XOR of x and x/2. The result will have a bit set to 1 for every switch in the input number plus 1, and so we just need to get the number of digits in base 2, and their sum. Then add some parentheses, and make it a float.

Python 3, 105 chars

def s(n):b=bin(n)[2:];l=len(b);c=sum([0if b[i]==b[i+1]else 1for i in range(l-1)]);return l/c if c>0else-1

Returns -1 in the case of an infinity.

Python 3.8 (pre-release), 60 bytes

Port of G B's Ruby answer.

lambda l:(c:=(b:=bin(l^l>>1)).count('1'))>1and(len(b)-2)/~-c

Try it online!

Python 2, 68 bytes

Returns false if the value is infinite.

k=input()

n=s=0

while k:l=k%2;n+=1.;k/=2;s+=l^k%2

print s>1and n/~-s

Try it online!