More easy way of using Interfaces to map YAML dynamically?

I am trying to parse a yaml file dynamically (Therefore no struct).

package main

import (
	"fmt"
	"gopkg.in/yaml.v2"
	"log"
)

func main() {	
	var out = `
a: First!
f: Second
b:
  c: 
    f: Third
`
	m := make(map[interface{}]interface{})
	err := yaml.Unmarshal([]byte(out), &m)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(m["b"].(map[interface{}]interface{})["c"].(map[interface{}]interface{})["f"])
}

Everytime I have to access a subkey, I am forced to convert map variable in question to (map[interface{}]interface{}). This is causing bit of a hassle for me as I have to iterate through the map.

Is there any easier method for parsing YAML file in Go?

Another approach is to flatten the yaml data structure into a key,value map in which keys and values are strings. Then if you need the actual type (5 being an int) you can do the conversion yourself. Example:

"a" = "First!"
"f" = "Second"
"b.c.f" = "Third"
"b.c.g.size" = "2"
"b.c.g.0 = "zero"
"b.c.g.1 = "one" 

In Go:

func main() {
	any := map[string]interface{}{}
	err := yaml.Unmarshal([]byte(out), &any)
	if err != nil {
		log.Fatal(err)
	}

	flatmap := map[string]string{}
	for k, v := range any {
		flatten(k, v, flatmap)
	}

	for k, v := range flatmap {
		fmt.Println(k, "=", v)
	}
}

func flatten(prefix string, value interface{}, flatmap map[string]string) {
	submap, ok := value.(map[interface{}]interface{})
	if ok {
		for k, v := range submap {
			flatten(prefix+"."+k.(string), v, flatmap)
		}
		return
	}
	stringlist, ok := value.([]interface{})
	if ok {
		flatten(fmt.Sprintf("%s.size", prefix), len(stringlist), flatmap)
		for i, v := range stringlist {
			flatten(fmt.Sprintf("%s.%d", prefix, i), v, flatmap)
		}
		return
	}
	flatmap[prefix] = fmt.Sprintf("%v", value)
}