OngaLog

最近GOが楽しくて、

Keras 事はじめ

Kerasを使ってCSVから読み込んだデータを元にしてmodelの学習及びserver化を実行してみる。

https://keras.io/ja/

train.py

データはcsvから読み込んでみました。tensorflowの場合はload_csv_with_headeというメソッドからcsvを読み込んでいましたが、kerasには専用のmehodが用意されていないようなので、numpyのgenfromtxtの機能を使って読み込んでみる。load_csv_with_headeと同じように、最終行を正解値として設定。dtype=intとしているのだけど、float型が混じっていた場合どうでるべきなのだろうか、ひとまず今回はint型のみで完結するデータを作成してみました。

X = genfromtxt('./some.csv',
               delimiter=',',
               skip_header=1,
               usecols=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
               dtype=int)
Y = genfromtxt('./some.csv',
               delimiter=',',
               skip_header=1,
               usecols=(15),
               dtype=int)

input_dimデータ形式に従って15に設定、output_dimは30に、ここはチューニグが必要そう、今回のデータ量ではoutputの値によって精度が変わっている様子は見受けられなかったので、全体的な把握がまだできていないかもしれない。

model.add(Dense(input_dim=15, output_dim=30))

学習したmodelを使って、predictを実行、5000回のepochでそこそこ精度はでるようになりました。

results = model.predict_proba(np.array(
    [
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    ]
))

学習データを保存する為にsave_weightsでデータを保存、HDF5形式のファイルで保存される。ただ、詳細はわかっていないのだけど、互換性のあるデータなのだろうか。

model.save_weights('./learnedModel')

server.py

まず、作成済みのモデル定義を読み込み。

 Sequential.from_config()

次に、学習済みの重みを読み込み。

model.load_weights

以上の手順で無事server化に成功。 学習データを再現したAPIサーバーも手軽に立てる事ができそうです。

github.com

Go言語を使ってLineBotを作成してみる

AppEngineとGo言語でLineBotを作成するサンプル

f:id:loosefingers:20170228233709p:plain

Line-Bot-Sandbox

github.com

Go言語でテキストの文字数制限を実行するライブラリ

onga-tec.hatenadiary.jp

以前Goで文字数制限処理をするのにはどうすればいいのか悩んだのだが、 WEBアプリケーションを作成する際に表示文字数制限はよく利用するのでライブラリとしてまとめてみました。

go-text-export

github.com

インストール方法

go get github.com/tkc/go-text-export

簡単な利用方法

Contrary to popular belief, Lorem Ipsum is not simply random text.
It has roots in a piece of classical Latin literature from 45 BC,

上記のようなテキストに対して、チェインメソッドを実行します。

go_text_export.Create(Str).Export(100).SetMoreText(" more..").RemoveWhiteSpace().String()

結果

Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of  more..

ほかにも、テキストからリンクを抽出する処理や改行を置換する処理を実装しています。 何気に面倒な処理が楽になります。 試してみてください。

Go Nested Json Unmarshal

GoでNestされたjsonの扱いがわからなかったのでメモ。

 jStr := `
    {
        "root": {
            "c1": ["cv1"],
            "c2": ["cv2"]
        }
    }
    `

        type Children struct {
                c1 []string `json:"c1"`
                c2 []string `json:"c2"`
        }

        type Root struct {
                c Children `json:"root"`
        }

        var root Root
        if err := json.Unmarshal([]byte(jStr), &root); err != nil {
                log.Fatal(err)
        }
        log.Printf("%+v\n", root)
        

このパッケージも良さそう。 github.com

Go からBIgQueryを扱うサンプル

Goを使ってAWSからBIgQueryにアクセスする必要があるときの処理。

package bigquery

import (
        "log"
        "reflect"
        "io/ioutil"
        "golang.org/x/oauth2"
        "golang.org/x/oauth2/google"
        "google.golang.org/api/bigquery/v2"
)

const projectId = "***"
const dataSetId = "***"
const tableName = "***"

// Type:
// STRING, BYTES, INTEGER, FLOAT, BOOLEAN, TIMESTAMP, DATE, TIME, DATETIME,

type TableModel struct {
        Name    string `column:"name" bq_type:"STRING" bq_mode:"NULLABLE"`
        Address string `column:"address" bq_type:"STRING" bq_mode:"NULLABLE"`
}

func CreateTableSchema(tableModel interface{}) bigquery.TableSchema {

        var schemas = &bigquery.TableSchema{}
        fields := []*bigquery.TableFieldSchema{}
        rt := reflect.TypeOf(tableModel)

        for i := 0; i < rt.NumField(); i++ {
                field := rt.Field(i)
                fields = append(fields,
                        &bigquery.TableFieldSchema{
                                Mode: field.Tag.Get("bq_mode"),
                                Name: field.Tag.Get("column"),
                                Type: field.Tag.Get("bq_type"),
                        },
                )
        }

        schemas.Fields = fields
        return *schemas
}

func CreateInsertRow(tableModel interface{}) []*bigquery.TableDataInsertAllRequestRows {

        rows := make([]*bigquery.TableDataInsertAllRequestRows, 0)
        row := &bigquery.TableDataInsertAllRequestRows{
                Json: make(map[string]bigquery.JsonValue, 0),
        }
        rt := reflect.TypeOf(tableModel)
        rv := reflect.ValueOf(tableModel)

        for i := 0; i < rt.NumField(); i++ {
                value := rv.Field(i).Interface()
                field := rt.Field(i)
                row.Json[field.Tag.Get("column")] = value
                rows = append(rows, row)
        }

        return rows
}

func BqSample() {

        pemKeyBytes, err := ioutil.ReadFile(<your file path>)

        if err != nil {
                panic(err)
        }

        t, err := google.JWTConfigFromJSON(pemKeyBytes, "https://www.googleapis.com/auth/bigquery")

        if err != nil {
                panic(err)
        }

        /*
            Make DataSet
        */

        client := t.Client(oauth2.NoContext)
        service, _ := bigquery.New(client)

        datasetList, _ := service.Datasets.List(projectId).All(false).Do()

        for _, dataset := range datasetList.Datasets {
                log.Print(dataset.DatasetReference.DatasetId)
        }

        /*
            DataSet Get
        */

        Dataset, _ := service.Datasets.Get(projectId, datasetId).Do()
        if Dataset != nil {
                log.Print(Dataset.DatasetReference.DatasetId)
        } else {
                log.Print("dataset not exist")
        }

        ds := bigquery.Dataset{
                DatasetReference:&bigquery.DatasetReference{
                        ProjectId:projectId,
                        DatasetId:"test_dataset",
                },
        }

        /*
            Table List
        */

        service.Datasets.Insert(projectId, &ds).Do()
        TableList, _ := service.Tables.List(projectId, dataSetId).Do()

        for _, tableListTables := range TableList.Tables {
                log.Print(tableListTables.TableReference.TableId)
        }

        /*
            Table Get
        */

        tableListTables, _ := service.Tables.Get(
                projectId,
                dataSetId,
                tableName).Do()

        if tableListTables != nil {
                log.Print(tableListTables.TableReference.TableId)
        } else {
                log.Print("table not exist")
        }

        /*
            Make Table 
        */

        schema := CreateTableSchema(TableModel{})

        table := bigquery.Table{
                TableReference: &bigquery.TableReference{
                        DatasetId: dataSetId,
                        ProjectId: projectId,
                        TableId: tableName,
                },
                Schema:&schema,
        }

        tableRes, _ := service.Tables.Insert(
                projectId,
                dataSetId,
                &table).Do()

        log.Print(tableRes)


        /*
            InsertAll 
        */

        res, _ := service.Tabledata.InsertAll(
                projectId,
                dataSetId,
                tableName,
                &bigquery.TableDataInsertAllRequest{
                        Kind: "bigquery#tableDataInsertAllRequest",
                        Rows: CreateInsertRow(TableModel{Name:"name", Address:"address"}),
                }).Do()

        log.Print(res)


        /*
            Query 
        */

        query := "SELECT address FROM [<project-name>:<dataset-name>.<table-name>] LIMIT 1000"

        result, err := service.Jobs.Query(projectId, &bigquery.QueryRequest{
                Kind:  "bigquery#queryRequest",
                Query: query,
        }).Do()

        for _, row := range result.Rows {
                log.Print(row)
                for _, cell := range row.F {
                        log.Print(cell.V)
                }
        }

}

gist

gist:113726894216fa2982a541362028a696 · GitHub