常連

テラテイラー

回答者

ベストアンサー

拍手喝采

プロフェッサー

先生

有名人

現在、PHPとAPI(Go)を組み合わせたシステムの開発環境をdockerで構築しようとしています。

その構築方法、また開発方法について疑問点が2点ございますので、よろしければご回答頂ければ幸いです。

#####①dockerをPHPとAPIで個別に立てるべきかどうか
PHPとAPI間は、PHPから出力したファイルの内容をAPIが読み取ることで処理を実施します。
そのため、dockerが個別になるとPHP側のdockerから出力したファイルをAPI側のdockerが受信させるという処理が必要になると思いますが、これはフォルダのマウント機能を利用して運用する感じになるのでしょうか？
それとも、PHP,APIは同じdocker内に構築するべきでしょうか？

####②gitを使用した開発方法について
例えば、APIのdockerを構築するためにgit cloneでAPIのソースをdocker内に取り込んだあと、そのままdocker上で開発したあとはgitへcommitし、また同じdocker上で開発を続けるという流れになるんでしょうか？
しかしこれではvagrantと運用が何も変わらないので、開発は別途違うところで行って完成したソースをdcokerにgit cloneで取り込んで、docker上で動作確認を行い、何も問題なければそのdockerを本番にデプロイする、、という流れが正しいのでしょうか？

以上、よろしくお願いいたします。

dockerを使った開発方法について

現在Dockerでサイトを作りながら学んでおります。
Dockerのベースイメージとしてalpine、サーバーOSとしてCentOSを採用しています。
ここで疑問に思ったのですが、なぜベースイメージをcentosではなくalpineにしても動くのでしょうか？
(centosではなくalpineを使っているのはalpineがいいとネットで見たため)

Dockerの仕組みから、
「OSの名前はついているが、ベースイメージはOS的役割をするのではなく、そのOSっぽい環境を整える(ディレクトリ構成をそのOSっぽくするなど)のが役割」と予想しているのですが、どうなのでしょうか？

DockerのベースイメージがホストOSと違ってもいいのはなぜ？

再帰関数を引数に取る高階関数を書いていたのですが、ちょっとつまづきました。
試行錯誤の上、動くもの自体は出来たのですが、自分の考えた対策は変数巻き上げを使わないといけないため、あまり読み手（将来の自分）にとって分かりづらいなと感じています。

それを変数巻き上げを使わずに別のより読み手に分かりやすい方法で行えないかと思っております。

言葉での説明が上手く出来そうにないので、質問用に用意した簡易的なコードで説明をいたします。

※極力、ES6を使わずに書きました。

# 高階関数に渡す関数

```
function func(n) {
	
	if (!n) return;
	
	console.log('#'.repeat(n));
	
	newFunc(--n);
}

func(5);

#####
####
###
##
#
```

単純に#を関数の引数に渡された数だけ出力するという処理を引数が０になるまで繰り返すというものです。

# 高階関数

```ここに言語を入力
function hof(fn) {
	
	const hr = '-----' 
	
	return function inner() {
		
		console.log(hr);
		
		const args = Array.prototype.slice.apply(arguments);

		fn.apply(this, args);
	}
	
}

function func(n) {
	
	if (!n) return;
	
	console.log('#'.repeat(n));
	
	newFunc(--n); //★関数スコープ外のnewFuncを参照
}

const newFunc = hof(func);
newFunc(5);

-----
#####
-----
####
-----
###
-----
##
-----
#
-----
```

質問用に用意した簡易的なコードのため、機能としては意味がないですが、
単純に区切り線を追加する高階関数です。

**このコード自体は期待した動作をします。**



# でも、本当はこうしたかった

```
function func(n) {
	
	if (!n) return;
	
	console.log('#'.repeat(n));
	
	func(--n); //★これだと元の`func`を再帰実行してしまう！
}

const newFunc = hof(func);
newFunc(5);

-----
#####
####
###
##
#
```

こちらの方が読み手にとって直感的で分かりやすいと思うのですが、、、

**出力される結果は期待通りのものにはなりません。**

原因はコード内のコメントに記した通りです。

そのため、最初に載せた高階関数のコードにたどり着いたのですが、やはり、外のスコープの変数を参照しているということと、変数の巻き上げを使っているというところで、僕的には読みづらいと感じてしまいます。
特に実際のコードはこれよりも長い為。

こういう場合は、何か出来る対策はあるのでしょうか？

# 補足

**質問に掲載しているサンプルコードは、表題のことを示す以外の意味はありません。**

そのため、「サンプルコードの場合であれば、再帰をつかなくてもこう出来る、高階関数使わなくてもこう出来る」のような話ではなく、以下の条件を前提とした質問となります。

- 再帰処理が行われる
- その再帰関数(fn1)を別の関数(fn2)の引数に渡して実行する
- 再帰関数(fn1)を渡す別の関数(fn2)のスコープにある変数を再帰関数(fn1)は参照する（キャッシュ等）

※別の例を挙げると、フィボナッチの再帰的に行う関数をメモ化したようなものをイメージするとわかりやすいかもしれません。

再帰関数を引数に取りそれを実行する高階関数のコンテキストを変数巻き上げを使わずに変える方法

teratailには素晴らしいエンジニア経験をお持ちの方がいらっしゃると思うので質問させてもらいます。

タイトルの通りになりますが、
**「書くコードが酷い開発会社（ベンチャー）」**で働いた経験がある方（なくても似たような経験をした）に特に回答頂けたらとても嬉しいです。

プログラマーの皆様は「コードの品質」というものに、どれだけこだわりを持っていますか？

## 現状
Web系エンジニア経験２年未満。諸事情で転職活動中。
ある経由でお話を頂いて、タイトルの通りのような会社に入社を考えています。
理由は現職の給与面のあまりの低さと残業と通勤時間から起因する「プライベートの時間のなさ」です。

## 自分の実務での経験
エンジニアとして「コーディング規約に則ったキレイなコード」を書くようにずっと教えられてきた。
CI導入も積極的にして自動テストもちゃんと書く。
リファクタリングなども積極的に行う。
誰が見ても読みやすいコードを書く。コードの品質も求める。

「パフォーマンスの面での良いコード」の追求はまだ力不足で全然出来ていない。
「コードの生産量」も同じくまだまだだと思います。

といった感じで今までプログラマーとしてやってきました。

## 入社予定の会社
今までの経験とは真反対。プロジェクトのソースコードを見たりお話を聞いた限りだとこんな感じでした。

「コードの品質はどっちでもいい。とりあえず動けばいい。」
「テストは基本的に書かない。」
「コードは基本的に動けばいいのでコーディング規約も存在しないし、人それぞれ」
「とりあえずgitで管理しているけど、コミット内容やメッセージも統一がない」

基本的に人も会社も若いのでコードのレベルも未熟？
トップが納品重視なので工数がかさむことはしたくない。

## 期待面
給与面、会社の自由な規則から来る時間的な余裕
（今までは仕事で１日が終わり、プライベートでコードを書くことや、勉強会などには中々行けませんでした。）

「酷いコードを直していく」「良いコードを書く」といった指導する教えられる立場になれる？（今までプログラマーとして周りの指導などしてこなかったのでそういったスキルも欲しい。）

## 不安面
周りの技術レベルがかなり落ちるはず
まだまだレベル的には新米プログラマーなので、技術で背中を追う先輩方が居なくなる不安
「酷いコードを書く」環境に馴染まないかどうか

## まとめ
自分に実力があれば、技術責任者としてバシバシ引っ張っていけるかもしれないが、現状の実力は全然。
ただプログラマーとして「コードの品質を重視したい」という思想だけが先行している。

以上を踏まえてプログラマーとして

「コードの品質を求めるプログラマー」を目指すならやはりそういった会社だけを渡り歩いていくのがいいのか。
それとも経験としてこういった会社で開発する事もこれから数十年やるプログラマー生活で必要なのか。
というのを悩んでいる段階です。

皆さんはどういった経験をしてきてどういった「プログラマー」に現状なっていますか？
アドバイス頂けるとありがたいです。

皆さんにお聞きしたいです。「書くコードが酷い会社」で働いて得る経験は大きいと思いますか？

機械学習分野には
『XX分布でサンプリングする』とか『NNの出力をXX分布にする＝XX分布であるようNNの出力をさせる？』という表現ありますが。
理解できません。

「サンプル(そのもの)がXX分布になっている」のような表現は分かりますが、
人間の意志によってわざわざ**『特定の分布』**でサンプリングするのはどうやって実現するのでしょうか。

同様に、どうやって『NNの出力をXX分布にする』のでしょうか。
例えば、
Variational Auto Encoder(VAE)のgeneratorの出力は(μ,σ)Gaussian分布にさせるとか。
要は特定の数値やパターンが出力するようにする事は分かりますが、
その数値やパターンを**特定の分布に従わせる**方法は分かりません。

どうぞ宜しくお願いします。

ある分布でサンプリングと出力とは？

python初心者です
二値化した画像(.jpg)を配列に入れました
配列が

[1 1 1 1 1 1 1 1 0 1 0 0 0 0 0]
[1 1 1 1 1 1 1 1 0 0 0 0 0 0 0]
[1 1 1 1 1 1 1 1 1 1 0 0 0 0 0]

のようになっているとき，連続した1の数をカウントするソースコードを教えていただきたいです
1の数を数えるソースコードは調べれば出てくるのですが、連続した数字を数えるソースコードは出てきません


よろしくお願いいたします

実際には画像ファイルが多く，ピクセル数も多いため時間がかかってしまいます
1,0の境界の位置を探してそのピクセル数を得るのに時間短縮できる方法があれば，教えていただけると有難いです
最終的には写真から輪郭形状のグラフを作りたいと思っています

numpyの連続した数値列のカウント

お世話になっています。

質問文が長くなってしまいましたので、聞きたい内容からです。
「TCPヘッダにあるウィンドウサイズを確認し、受信したメッセージデータがウィンドウサイズと一致していれば次のメッセージを待つ」
……という事をNode.jsのnetライブラリでどうすれば実現出来るか教えてください。

無理なら無理でも大丈夫です。
無理な場合、諦めて回避策を実施しようと考えています。
（一応下に共有しています）

## 状況説明

Node.jsでTCPサーバを構築しています。
開発は滞り無く進み結合テストまでいきました。

※本当はモジュール化されていますが、今回は質問の為に必要なコードを別のファイルから引っ張ってきて同じスコープ内にまとめています。

```JavaScript
const net = require('net')

// receive_from_router :: Socket -> Buffer -> Undefined
const receive_from_router = (socket, buf) => {
  // バッファー文字列のバリデート
  // 妥当なデータならばDBに問い合わせたり保存したり色々する
  // また、動作の成否を元に接続したクライアントに結果を返す
  socket.write(result, () => client.end())
}

const server = net.createServer(socket => {
  socket.on('data', data => receive_from_router(socket, data))
  socket.on('end', () => console.log(`${socket.remoteAddress}: disconnected.`)
})
server.on('connection', socket => console.log(`${socket.remoteAddress}: connected.`))
server.on('error', err => console.error(err))
server.listen(45000)
```

## 問題発生

結合テスト中に、接続したクライアントが超長いバイト文字列を送りつけて来ました。
そのサイズ……実に2,576Byte！！
意外としょぼいですがTCPが一度に受け取れるパケットサイズは大したことなく、
1,440Byte目で区切られてしまい、2度`data`イベントが発火している事が分かりました。

その結果、2つに分けられたメッセージはどちらもバリデートエラーで捨てられてしまいました。

- 1度目のメッセージ: データ量が足りず必須項目の入力エラー
- 2度目のメッセージ: 変に途中から始まっているので、メッセージ内のヘッダー情報が不正

connectListenerで作られるsocketを、data内部でconsole.logで出力してみました。

1回目は`socket._handle.bytesRead`の中身が1440で、2回目は2576でしたが、
他には使えそうな情報はなさそうです。
他のサイトの情報を元に`socket.bufferSize`も確認しましたが、dataイベントの中身では0が返ってきただけでした。

```
Socket {
  connecting: false,
  _hadError: false,
  _handle: 
   TCP {
     bytesRead: 1440,
     _externalStream: [External],
     fd: 14,
     reading: true,
     owner: [Circular],
     onread: [Function: onread],
     onconnection: null,
     writeQueueSize: 0 },
  _parent: null,
  _host: null,
  _readableState: 
   ReadableState {
     objectMode: false,
     highWaterMark: 16384,
     buffer: BufferList { head: null, tail: null, length: 0 },
     length: 0,
     pipes: null,
     pipesCount: 0,
     flowing: true,
     ended: false,
     endEmitted: false,
     reading: false,
     sync: false,
     needReadable: true,
     emittedReadable: false,
     readableListening: false,
     resumeScheduled: false,
     destroyed: false,
     defaultEncoding: 'utf8',
     awaitDrain: 0,
     readingMore: false,
     decoder: null,
     encoding: null },
  readable: true,
  domain: null,
  _events: 
   { end: [ [Object], [Function] ],
     finish: [Function: onSocketFinish],
     _socketEnd: [Function: onSocketEnd],
     data: [Function] },
  _eventsCount: 4,
  _maxListeners: undefined,
  _writableState: 
   WritableState {
     objectMode: false,
     highWaterMark: 16384,
     finalCalled: false,
     needDrain: false,
     ending: false,
     ended: false,
     finished: false,
     destroyed: false,
     decodeStrings: false,
     defaultEncoding: 'utf8',
     length: 0,
     writing: false,
     corked: 0,
     sync: true,
     bufferProcessing: false,
     onwrite: [Function: bound onwrite],
     writecb: null,
     writelen: 0,
     bufferedRequest: null,
     lastBufferedRequest: null,
     pendingcb: 0,
     prefinished: false,
     errorEmitted: false,
     bufferedRequestCount: 0,
     corkedRequestsFree: 
      { next: null,
        entry: null,
        finish: [Function: bound onCorkedFinish] } },
  writable: true,
  allowHalfOpen: false,
  _bytesDispatched: 0,
  _sockname: null,
  _pendingData: null,
  _pendingEncoding: '',
  server: 
   Server {
     domain: null,
     _events: { connection: [Array], error: [Function] },
     _eventsCount: 2,
     _maxListeners: undefined,
     _connections: 1,
     _handle: 
      TCP {
        bytesRead: 0,
        _externalStream: [External],
        fd: 11,
        reading: false,
        owner: [Circular],
        onread: null,
        onconnection: [Function: onconnection],
        writeQueueSize: 0 },
     _usingSlaves: false,
     _slaves: [],
     _unref: false,
     allowHalfOpen: false,
     pauseOnConnect: false,
     _connectionKey: '6::::40002',
     [Symbol(asyncId)]: 13 },
  _server: 
   Server {
     domain: null,
     _events: { connection: [Array], error: [Function] },
     _eventsCount: 2,
     _maxListeners: undefined,
     _connections: 1,
     _handle: 
      TCP {
        bytesRead: 0,
        _externalStream: [External],
        fd: 11,
        reading: false,
        owner: [Circular],
        onread: null,
        onconnection: [Function: onconnection],
        writeQueueSize: 0 },
     _usingSlaves: false,
     _slaves: [],
     _unref: false,
     allowHalfOpen: false,
     pauseOnConnect: false,
     _connectionKey: '6::::40002',
     [Symbol(asyncId)]: 13 },
  _peername: { address: '::ffff:118.238.220.66', family: 'IPv6', port: 61295 },
  read: [Function],
  _consuming: true,
  [Symbol(asyncId)]: 118,
  [Symbol(bytesRead)]: 0 }
```

## ゴールの定義

Bufferの結合は(パフォーマンスはともかく)これで行けそうです。
なので、素直に書けば下記のような感じのコードになるかと思います。

```JavaScript
// isFull :: Socket -> Boolean
const isFull = (socket, buf) => true // メッセージの状態から完了か否かを判別する
const server = net.createServer(socket => {
  const buffers = [];
  socket.on('data', data => {
    buffers.push(data)
    if (isFull(socket, data)) receive_from_router(socket, Buffer.concat(buffers))
  })
  client.on('end', () => console.log(`${socket.remoteAddress}: disconnected.`)
})
```

問題はこの`isFull`関数の判別ロジックをどうすれば良いのか？
状況だけ説明しておくと、クライアントは2メッセージ目を追撃で送信することはなく、レスポンスを待つだけです。
なのでnetライブラリの`end`イベントで引っ掛ける事も難しいのが現状です。
(`end`イベントはクライアントのFINに反応する仕様のようです)

TCPの仕様とNode.jsのnetライブラリの挙動は余り詳しくないので、
こうすれば検知出来るという答えがありましたら教えてください。

## 試行錯誤の跡

1,440Byteで区切られるなら、その文字列で切れば良いじゃないかと思ったのですがどうやらダメそうです。

> 一般的にはウィンドウ・サイズの初期値は数Kbytesから数十Kbytes程度である。この値は16bitの符号なし整数値で表現されるので、最大なら64Kbytesまで拡大することも可能であるが、現在ではTCP/IPの規格が拡張され、さらに大きなサイズにすることも可能となっている。

TCPの仕様でバッファーのオーバーフローを防ぐ為に可変式のウィンドウサイズというものが、
送受信されるパケットのヘッダー部にあり、それを元に最大文字列数が決定されているようです。

そこで「TCPヘッダにあるウィンドウサイズを確認し、受信したメッセージデータがウィンドウサイズと一致していれば待つ」が実現出来れば解決しそうだと考えているのですが、公式サイトのドキュメントから、このメッセージヘッダーやウィンドウサイズを確認する方法が分からず途方にくれています。

以下参考にしたサイト

- [第41回レイヤ４ TCP ウィンドウ - 3 Minutes NetWorking](http://www5e.biglobe.ne.jp/aji/3min/41.html)
- [第14回　信頼性のある通信を実現するTCPプロトコル（その1） (3/3)](http://www.atmarkit.co.jp/ait/articles/0312/25/news001_3.html)
- [Net - Node.js v9.10.1 Documentation](https://nodejs.org/api/net.html#net_event_end)
- [node/lib/net.js - GitHub](https://github.com/nodejs/node/blob/master/lib/net.js)

---

[Node.js TCP server incoming buffer - スタックオーバーフロー](https://stackoverflow.com/questions/5955498/node-js-tcp-server-incoming-buffer)

`this.disconnected`でクライアントが切断するまで待ってる設計
今回のクライアントはメッセージを送った後、バリデート結果等のレスポンスを受け取りたいのでFINを発射せず待っている。

## 結局どうしたか

今回は急遽クライアントとの連絡で使うメッセージの仕様を拡張し、
「今から送信するメッセージ長は2,576Byteですよ」という自己申告を埋め込んでおき、
受信したメッセージ長が1,440Byteなら、「ああ、更に1,136Byteが後で届くのね」という作りにして対応しようと考えています。

TCPの仕様はお互いが好き勝手にパケットを投げつけあって、その結果どう動くかは好きにしろみたいな仕様だと思います。
そこから今回の対応のように「今から送信するメッセージ長は2,576Byteですよ」とするのが一番自然なのかも知れないなとも考えています。

でも、今回のメッセージ分割は特別な操作をせずにTCPの仕様に従って自然と行われた事なので、
実は私が見落としているだけでウィンドウサイズを確認してよしなに実行出来る何かがあるんじゃないか？と考えています。
以上、長くなりましたがよろしくおねがいします。

## 追記1

Node.jsのnetなので、TCPの仕様が原因なのではなく、
単純にNode.jsのStreamの仕様が原因なのかもしれません。

その辺もあまり詳しくないので、Node.jsの内部実装に詳しい方から見れば的外れな考察しているかも知れないと考えています。

TCPサーバ(net)でバッファーのオーバフローを検知したい

最近SPAについて勉強しています。

SPAでは、クライアントサイドレンダリングが基本だと思います。
Vue.js や React を用いてビュー部分をブラウザにわたし、サーバーサイドではAPIのみを提供しページの構築を行うと思います。

例えば、「管理者なら管理用メニュー、一般ユーザーなら普通のメニューを表示する」のようなロジックを例にすると、ビュー（ここでは Vue.js を使用すると仮定）では次のような実装が考えられると思います。

```html
<div v-if="userType === 'user'">
   	
</div>
<div v-if="userType === 'admin'">
	
</div>
```

善良なユーザーが使う分には問題無いと思いますが、悪意あるユーザーがコンソールで「userType = 'admin';」などと入力しただけで管理用メニューが表示されてしまいます。

また、そうでなくても表示されないにしろ、HTML/JSに管理用メニューの名前、及びAPIのアクセス先が書いてあるため、API側で何かしらの認証処理をするという前提があったとしても、管理用メニューにどういうものがあるのかを見られてしまうのは脆弱性につながりかねません。

このような点に関してどのような対処をするのが一般的なのでしょうか？


[追記]
皆さん、回答ありがとうございます！
質問の仕方が悪く、自分の伝えたい本質を書くことができていませんでした。

認証周りの話というよりはユーザー(ブラウザ)がコンポーネントに対する操作が可能ということに疑問を持っています。

コンソールからコンポーネントに渡すデータを変えればそのコンポーネントの挙動を変更することとが可能だと思います。

例えば入力フォームを作る場合に特定の条件のユーザーにはフォームを表示しないといったケース、
具体的にはアンケートでユーザーの会員情報で性別が女性の場合は化粧品についてのアンケートも追加で表示させるケースを考えたいと思います。

サーバーサイドレンダリングであればサーバー側でユーザーの性別を見て生成するHTMLを変更できます。

クライアントサイドレンダリングの場合は一旦全て送り、ユーザー側で非表示にさせるといった処理が考えられそうです。

ここでユーザーがコンソールから性別データをいじった場合、男性なのに化粧品のアンケートを表示させる、女性なのに化粧品のアンケートを表示させない のようなことが可能になってしまう気がします。

回答でいただいたコードスプリッティングなどで対応はできそうですが、こんな些細なものごとにいちいち分割しているとは思えません。

[追記2]
もちろんこれはSPAに限らずJavascript自体のリスクではあると思いますが、
サーバーサイドレンダリングの場合、JSは「見た目の操作」にのみ使われてることが多いと思います。
SPAではややロジックも担当している印象を受けたためこのような質問をしました。

ユーザーからの挙動変更が可能なリスクがある中でどのような策がなされているのか、あるいはなすべきなのか 教えていただきたいです。

SPA・クライアントサイドレンダリングはセキュリティ的に安全なのでしょうか？

oookabe様の質問記事【D-CNNの画像特徴抽出に対する誤解？】
(https://teratail.com/questions/118130)の中に下記内容が書かれました:
##
【2】 D-CNNでは同一objectであっても、D-CNNにより抽出された「画像特徴data」はそのobjectが属するclassの他のメンバーの画像内容に左右され、一定ではない！ 

【3】 D-CNNでは同一objectであっても、D-CNNにより抽出された「画像特徴data」はそのobjectが属するclassのlabel値に左右される (突飛！) 
##
自分も少し画像特徴抽出するような仕事を担当した事がありますが、
D-CNNによる"特徴抽出"の性格は本当に【2】と【3】に指摘された通りのもんであれば、
それこそ『**自動特徴抽出**』と『**人工特徴抽出**』との本質的な違いだと考えて宜しいでしょうか。

CNNに関する他人の"感覚"からですけれども

###前提・実現したいこと
Python（Keras）でCNNを用い2種類の画像を判別するプログラムを作っております。
その時に学習したモデルを活用して判定時にどこに注目したのかを
grad-camにより、表現したいと考えております。
grad-camについては
https://github.com/jacobgil/keras-grad-cam/blob/master/grad-cam.py
こちらのコードを参考にしており自分のモデルに合わせて対象箇所を変えたつもりです。

モデルはこちらになります。
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 62, 62, 32)        896       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 31, 31, 32)        0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 31, 31, 32)        0         
_________________________________________________________________
zero_padding2d_1 (ZeroPaddin (None, 33, 33, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 31, 31, 96)        27744     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 15, 15, 96)        0         
_________________________________________________________________
dropout_2 (Dropout)          (None, 15, 15, 96)        0         
_________________________________________________________________
zero_padding2d_2 (ZeroPaddin (None, 17, 17, 96)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 15, 15, 96)        83040     
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 7, 7, 96)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 4704)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              4817920   
_________________________________________________________________
dropout_3 (Dropout)          (None, 1024)              0         
_________________________________________________________________
dense_2 (Dense)              (None, 2)                 2050      
=================================================================
Total params: 4,931,650
Trainable params: 4,931,650
Non-trainable params: 0
_________________________________________________________________


###発生している問題・エラーメッセージ

```
IndexError                                Traceback (most recent call last)
<ipython-input-3-2fe13b62daac> in <module>()
    128 
    129 predicted_class = np.argmax(predictions)
--> 130 cam, heatmap = grad_cam(model, preprocessed_input, predicted_class, "conv2d_3")
    131 cv2.imwrite("gradcam.jpg", cam)
    132 

<ipython-input-3-2fe13b62daac> in grad_cam(input_model, image, category_index, layer_name)
     92 
     93     loss = K.sum(model.layers[-1].output)
---> 94     conv_output =  [l for l in model.layers[0].layers if l.name is layer_name][0].output
     95     grads = normalize(K.gradients(loss, conv_output)[0])
     96     gradient_function = K.function([model.layers[0].input], [conv_output, grads])

IndexError: list index out of range
```

###該当のソースコード
```python
from keras.preprocessing import image
from keras.layers.core import Lambda
from keras.models import Sequential ,load_model
from tensorflow.python.framework import ops
import keras.backend as K
import tensorflow as tf
import numpy as np
import keras
import sys
import cv2

def target_category_loss(x, category_index, nb_classes):
    return tf.multiply(x, K.one_hot([category_index], nb_classes))

def target_category_loss_output_shape(input_shape):
    return input_shape

def normalize(x):
    # utility function to normalize a tensor by its L2 norm
    return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)

def load_image(path):
    img_path = path
    img = image.load_img(img_path, target_size=(64, 64))
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=0)
    return x

def register_gradient():
    if "GuidedBackProp" not in ops._gradient_registry._registry:
        @ops.RegisterGradient("GuidedBackProp")
        def _GuidedBackProp(op, grad):
            dtype = op.inputs[0].dtype
            return grad * tf.cast(grad > 0., dtype) * \
                tf.cast(op.inputs[0] > 0., dtype)

def compile_saliency_function(model, activation_layer='conv2d_3'):
    input_img = model.input
    layer_dict = dict([(layer.name, layer) for layer in model.layers[1:]])
    layer_output = layer_dict[activation_layer].output
    max_output = K.max(layer_output, axis=3)
    saliency = K.gradients(K.sum(max_output), input_img)[0]
    return K.function([input_img, K.learning_phase()], [saliency])

def modify_backprop(model, name):
    g = tf.get_default_graph()
    with g.gradient_override_map({'Relu': name}):

        # get layers that have an activation
        layer_dict = [layer for layer in model.layers[1:]
                      if hasattr(layer, 'activation')]

        # replace relu activation
        for layer in layer_dict:
            if layer.activation == keras.activations.relu:
                layer.activation = tf.nn.relu

        # re-instanciate a new model
        new_model = model
    return new_model

def deprocess_image(x):
    '''
    Same normalization as in:
    https://github.com/fchollet/keras/blob/master/examples/conv_filter_visualization.py
    '''
    if np.ndim(x) > 3:
        x = np.squeeze(x)
    # normalize tensor: center on 0., ensure std is 0.1
    x -= x.mean()
    x /= (x.std() + 1e-5)
    x *= 0.1

    # clip to [0, 1]
    x += 0.5
    x = np.clip(x, 0, 1)

    # convert to RGB array
    x *= 255
    if K.image_dim_ordering() == 'th':
        x = x.transpose((1, 2, 0))
    x = np.clip(x, 0, 255).astype('uint8')
    return x

def grad_cam(input_model, image, category_index, layer_name):
    model = Sequential()
    model.add(input_model)

    nb_classes = 2
    target_layer = lambda x: target_category_loss(x, category_index, nb_classes)
    model.add(Lambda(target_layer,
                     output_shape = target_category_loss_output_shape))

    loss = K.sum(model.layers[-1].output)
    conv_output =  [l for l in model.layers[0].layers if l.name is layer_name][0].output
    grads = normalize(K.gradients(loss, conv_output)[0])
    gradient_function = K.function([model.layers[0].input], [conv_output, grads])

    output, grads_val = gradient_function([image])
    output, grads_val = output[0, :], grads_val[0, :, :, :]

    weights = np.mean(grads_val, axis = (0, 1))
    cam = np.ones(output.shape[0 : 2], dtype = np.float32)

    for i, w in enumerate(weights):
        cam += w * output[:, :, i]

    cam = cv2.resize(cam, (64, 64))
    cam = np.maximum(cam, 0)
    heatmap = cam / np.max(cam)

    #Return to BGR [0..255] from the preprocessed image
    image = image[0, :]
    image -= np.min(image)
    image = np.minimum(image, 255)

    cam = cv2.applyColorMap(np.uint8(255*heatmap), cv2.COLORMAP_JET)
    cam = np.float32(cam) + np.float32(image)
    cam = 255 * cam / np.max(cam)
    return np.uint8(cam), heatmap

# 判定画像の読み込み
preprocessed_input = load_image('image.jpeg')

model = load_model('mymodel.h5')
model.summary()

predictions = model.predict(preprocessed_input)

predicted_class = np.argmax(predictions)
cam, heatmap = grad_cam(model, preprocessed_input, predicted_class, "conv2d_3")
cv2.imwrite("gradcam.jpg", cam)

register_gradient()
guided_model = modify_backprop(model, 'GuidedBackProp')
saliency_fn = compile_saliency_function(guided_model)
saliency = saliency_fn([preprocessed_input, 0])
gradcam = saliency[0] * heatmap[..., np.newaxis]
cv2.imwrite("guided_gradcam.jpg", deprocess_image(gradcam))
```

###試したこと
1行1行入力してみたもののどこが問題かわからず、
もともと専門外で初心者なこともあり、お手上げ状態です…

###補足情報(言語/FW/ツール等のバージョンなど)
tensorflow (1.1.0)
Keras (2.0.4)

【Keras】grad-camの実装において自作の学習済モデルを作りたい…がエラーが出ます…

[リンク内容](https://drive.google.com/file/d/1cFI4USDzzr9qygxjKEAh7UzGdi02NJa5/view?usp=sharing)![イメージ説明](b2cf782626efea5b815eecfd75e73916.png)
LSTMを使って有る時系列データの予測を行ってみたところ、
不自然に正答率が良すぎる結果となってしまいました。
CSVから読み込んだデータをトレーニング用データとテスト用データに分割し、
トレーニング後にテスト用データを使ってpredictさせています。
Look_backは12で学習は300回行いました。
predictの結果としましては
トレーニングが13.44 RMSEに対して
テストデータ予測時が8.96 RMSEとなりました。
トレーニング用の部分とテスト予測時のデータを見比べてみると
周期的ではないように見えますし、ここまでうまく予測できるはずはないのでは？と考えております。

X(t-11) ～ X(t) までのデータからX(t+1) を予測するというのを繰り返していると考えているのですが、
以下

ソースコードと予測結果のグラフを観て何かおかしな箇所有りますでしょうか？
※グラフはブルーが実際のデータ
オレンジがトレーニング後　トレーニングデータを用いてpredictしたものになります。
緑はテストデータを用いてpredictを行った結果です。

結果が間違っているのでは？と思っておりますが、何か助言頂けないでしょうか？

アドバイスよろしくお願いいたします。

```python
import numpy
import matplotlib.pyplot as plt
import matplotlib.ticker as tick # 目盛り操作に必要なライブラリを読み込みます
import pandas
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error

#データ読み込み　Yは最初の列に配置する
dataframe = pandas.read_csv('/root/userspace/Hiwasawa/lesson3/LSTM/LSTMData3.csv', usecols=[2])


plt.plot(dataframe.iloc[:,0],label = "DataA")

plt.legend()
#目盛り関係
plt.gca().yaxis.set_major_locator(tick.MultipleLocator(500))
plt.show()

print(dataframe.head())

dataset = dataframe.values
dataset = dataset.astype('float32')

# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)

# split into train and test sets
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
print(len(train), len(test))

# convert an array of values into a dataset matrix
# if you give look_back 3, a part of the array will be like this: Jan, Feb, Mar
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        xset = []
        for j in range(dataset.shape[1]):
            a = dataset[i:(i+look_back), j]
            xset.append(a)
        dataY.append(dataset[i + look_back, 0])      
        dataX.append(xset)
    return numpy.array(dataX), numpy.array(dataY)

# reshape into X=t and Y=t+1
look_back = 12
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)
print(testX.shape)
print(testX[0])
print(testY)

# reshape input to be [samples, time steps(number of variables), features] *convert time series into column
trainX = numpy.reshape(trainX, (trainX.shape[0], trainX.shape[1], trainX.shape[2]))
testX = numpy.reshape(testX, (testX.shape[0], testX.shape[1], testX.shape[2]))


# create and fit the LSTM network
model = Sequential()
model.add(LSTM(4, input_shape=(testX.shape[1], look_back)))	#shape：変数数、遡る時間数
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=300, batch_size=1, verbose=2)

# make predictions
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
pad_col = numpy.zeros(dataset.shape[1]-1)

# invert predictions
def pad_array(val):
    return numpy.array([numpy.insert(pad_col, 0, x) for x in val])
    
trainPredict = scaler.inverse_transform(pad_array(trainPredict))
trainY = scaler.inverse_transform(pad_array(trainY))
testPredict = scaler.inverse_transform(pad_array(testPredict))
testY = scaler.inverse_transform(pad_array(testY))

# calculate root mean squared error
trainScore = math.sqrt(mean_squared_error(trainY[:,0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))

print(testY[:,0])
print(testPredict[:,0])
# shift train predictions for plotting
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
# shift test predictions for plotting
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict
# plot baseline and predictions
plt.plot((scaler.inverse_transform(dataset))[:,0])
plt.plot(trainPredictPlot[:,0])
plt.plot(testPredictPlot[:,0])
plt.show()
```

LSTMでテストデータの正答率が不自然に良すぎるのは何故でしょうか。

### 発生している問題・エラーメッセージ

```
当方、農作物の研究をしております。
過去十数年にわたり国内約100か所で気象データや土壌の状態に関する指標約80種を調査した結果がexcelのinputシートに、
また同年の収穫時期(1：9月上旬、2:9月中旬・・・6：月下旬として、多クラス分類されてます)を調査した結果が
同じブック内のanswerシートにそれぞれ約2000件入力されています。
これら80種の指標と収穫時期の関係をSVMで学習して当年の収穫時期の予測に活用できないかを試しており、以下を記述したところ、
得られるtest_dataの回答がすべて同じクラスになってしまいます。

```

### 該当のソースコード

```ここに言語名を入力
python3

import pandas as pd
import numpy as np
from sklearn import svm, metrics, cross_validation
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from mlxtend.plotting import plot_decision_regions

filename = "gloth.xlsx"
input_sheet_name = "input"
answer_sheet_name = "answer"

input_book = pd.read_excel(filename, sheet_name=input_sheet_name)
answer_book = pd.read_excel(filename, sheet_name=answer_sheet_name)

new_input_book = input_book.drop(0, axis=0)　#inputシートの0行目はデータ収集中のため、除外していいます。
new_answer_book = answer_book.drop(0, axis=0)　#answerシートの0行目はデータ未調査で空欄のため、除外しています。

xlsx_data = new_input_book[["MAX_TEM","MIN_TEM"・・・,"SEIIKU_1","SEIIKU_2"]] #指標はinputシートに80種程度入力しています
xlsx_label = new_answer_book[["Group"]] #収穫時期は多クラス分類してanswerシートに入力しています

train_data, test_data, train_label, test_label = cross_validation.train_test_split(xlsx_data, xlsx_label,test_size=0.2)

clf = svm.SVC(kernel='rbf', gamma=1/80, C=10.0)
clf.fit(train_data, train_label.values.ravel())

pre = clf.predict(test_data)

ac_score = metrics.accuracy_score(test_label, pre)
print("正解率＝", ac_score)

```

### 試したこと

print(pre)
でtest_dataの予測結果を確認したところ、いずれのデータの予測もすべて「1」として分類されているため、
正解率は16～20％と大変低くなってしまいます。

### 補足情報（FW/ツールのバージョンなど）

プログラムは、jupyter notebookで記述しています。
機械学習の勉強を始めて1か月程度の素人です。
不足している情報がありましたら
お伝えしたいと思いますので、よろしくお願いします。

SVMによる多クラス分類で予測すると、すべて同じクラスに分類される

### **背景**
最近この掲示板で皆さんにお伺いしながら、D-CNNの原理を初歩的に勉強した結果として、
次のような感覚を持ちました。

【1】 
D-CNNでは
米、車、海藻、虎 、、、のような外観特徴が人間からすれば完全に異なるobject同士を任意に組み合わせて一つの画像カテゴリー(class)に指定してトレーニングする可能だし、任意の実数label(scalar or vector)を指定可能
{**数学根拠**：NNでは任意の関数を生成可能}

【2】 
D-CNNでは
同一objectであっても、D-CNNにより抽出された「画像特徴data」はそのobjectが属するclassの他のメンバーの画像内容に左右され、一定ではない！

【3】 
同一objectであっても、D-CNNにより抽出された「画像特徴data」はそのobjectが属するclassのlabel値に左右される (突飛！)

【4】
D-CNNは本質的にvector量子化方法の一つ。
 
### **結論**

【1】 
D-CNNに抽出された「画像特徴」は人間の視覚的な「画像特徴」とは全然違う概念な量であり
人工画像特徴抽出のようなvisual semantic 性を持たない。
｛D-CNNに抽出された「画像特徴data」を可視化してedgeや平滑された部品をvisual的な要素に見えるのは単に元々は有意画像のため、それに対する加重平均処理(filter,所謂**「convolution」**) の結果も元の画像内容を反映しているに過ぎない ｝

【2】 
同じclassに属するobjectであっても D-CNNによって抽出された「画像特徴」はまちまちで、全然共通性を持たない可能性が高い(可比性なし)。

【3】
D-CNNに抽出された「画像特徴data」は、「**画像の固有特徴**」というより、単に指定した実数画像値vector(ie.,画像)を随意に指定した実数値(class label)に**射影**するための**数値合わせ的な**結果に過ぎない＝＝外部条件によって任意に変動する。

**画像の固有特徴 :** 各種moments, 輝度HIST、HOG、SIFT、topology不変量、、、 

【4】
D-CNNでやっている事は本質的に、複数のdata値(説明変数・自変数)を同一関数値に変換する射影関数と同じ。。。物性的な解釈ができず、数値計算上に成り立つための仕組みに過ぎず、
関数値が同じと言っても、対応する自変数同士の間のいかなる数値関係や数値の特性及び共通性を議論するのは無意味。
即ち、人工特徴抽出の場合のように、**画像特徴間の差や距離を測る事はD-CNNには通用しない**。

### **お願い**
間違った処ご指摘お願いします。

D-CNNの画像特徴抽出に対する誤解？

python中級者です。他人が書いた優秀なコードを使えるようになりたいので、pythonで他人が書いた効率のいいコード、優秀なコードが書いてある書籍やサイトがあったら教えていただけないでしょうか？

pythonで使えるコードが書いてある書籍やサイト

新しい Web サービスのアイディアがいくつもあるのに、現在それを作成できていると言える状況ではありません。

php + CodeIgniter で幾つかの Web サービスを運用しているのですが、この組み合わせでサービスを作るのは、結構無駄な時間がかかってしまっているイメージです。

それほど目新しい機能を必要としているものはないので、ブロックを積み重ねるように、プログラミングできれば、もっとスピード感のある開発ができるのではないかと思っており、Ruby on Rails に興味を持っています。

現在のスキルセットで考えると、laravel が適しているようにも思い、学習を始ようとしたところですが、その前に、識者の方々の知恵をお借りできればと思い質問します。

前置きが長くなってしまいましたが、以下のような条件の場合、どのようなフレームワークを選択して開発を進めていらっしゃるでしょうか？

・プロトタイプの作成が容易であり、機能の追加/改善/修正を頻繁に行う
・機能の追加/改善/修正において、多くの箇所を考慮したくない（機能同士が疎な結合）
・サービス全体としてのセキュリティポリシーの実現は考えなくてはならないが、コードレベルでのセキュリティバグ対応はあまり考慮したくない
・テストがそれなりに楽
・1 サーバで 1 Web サービスを提供するイメージ 
・まぁ、フロントもまとめて面倒みれると楽なんだろうなぁ。。。
・一人親方的開発なんで、グループ開発に対しての機能はチープで良い

概ね、上 4 つが望んでいる要件になります。
私のスキルセットはあってない程度のものなので、言語の縛りや既存のスキルセットは無視していただいてかまいません。

複雑なことをしたいというより、アイディア勝負のプロトタイプを量産していく感じで、オススメのフレームワークがあればよろしくお願いいたします。

プロトタイプをガンガン作っていくのに適したフレームワーク

機械学習の分野で異常検知という分野があります。その中に異常行動検出があり、オンラインで活用する実例のアルゴリズムとして「accesstracer」があります。
いろんな解説記事はあるのですが、pythonで実装した実例コードが見つかりません。
異常行動検出をpythonで実際に実装するために何か実例やサイトがありましたら教えていただけないでしょうか？

または実例コードがない場合、pythonで自力で実装する方法などありましたら参考に教えていただけないでしょうか？

異常検知の異常行動検出をpythonで実際に実装したいのですが、実例コードがない問題につい

初めまして
深層学習関連の質問掲示板があるのは以前知りませんでした。

自分は画像処理の経験少々あって、CNNは初めてです。
これまで画像objectを特定するために、人工的特徴によって行い、
多くの場合objectのサイズに関係なし(２－３倍の変動があっても)同定できます。
で、

【質問１】
CNNで学習したobjectのサイズとTEST画像に存在する実際のobjectのサイズとの間に
２－３倍の差があっても大丈夫でしょうか。

【質問２】
先進的なCNNとして resCNNがよく挙げられます。
現状のCNN lib、 例えば Tensorflow中のCNNはresCNNで実装されているのでしょうか。

【注】
resCNN はResidual Networkで実現したCNNと言うつもりで書いたのです。
**ResNeXt**が**もっと**進んだ方法であるらしいですね。

どうぞ宜しくお願いします。

=================================
【Note】
**注目すべき技術：**
●　SSD: Single Shot MultiBox Detector

●Using Machine Learning to Explore Neural Network Architecture 
https://research.googleblog.com/2017/05/using-machine-learning-to-explore.html

CNNに関する２つの質問

例えば、以下のコード
```C
#include<signal.h>

sig_atomic_t interrupted;

void sigint_handler(int signum){
     interrupted = 1;
}

int main(){
     signal(SIGINT, sigint_handler);
     while(!interrupted){
            [何かの処理]
     }
     return 0;
}
```
このコードは sig_atmoic_t interrupted にvolatileが付いていないので最適化するとバグります。

> main()からの読み取りは、コンパイラの最適化によって削除されてしまう可能性がある。

真っ先に思ったこと：「知らねぇぇぇ・・・ & なんで？？」
**最適化によって削除されたり、変更されたりする変数を把握することができません。**
**つまり、volatileが必要、不必要な場面がわからない。**ということです。

> 変数宣言にvolatile修飾子を追加すると、intterruptedはwhileループの繰り返しやシグナルハンドラからアクセスされる際に、必ず元のアドレスからアクセスされることが保証される。
キャッシュできないデータにはvolatileを使う

(キャッシュ？これは・・・CPUに備わっているキャッシュのことですかね？
元のアドレスとはなんのこと？)

**皆さんは、どうやってvolatileが必要な部分を見つけているんでしょうか？**

プログラムを作る -> 最適化するとバグる -> volatileが必要な部分を探す。

しかし、これだと**バグを前提に**volatileを探すことになるので、良い方法とは言えませんが・・・

あるパターンが存在するはずです。
**volatile修飾の規則を教えてください。**
しかし、全パターンを覚えるんですか？？
それは流石に無理ですよね？

__＿**[ここから私の妄想]**_____________
volatileによる最適化抑止機能は、変数に対してに加えて、**関数ごとに抑止できると便利ではないでしょうか？**
```C
volatile int buffer_ready;
char buffer[BUF_SIZE];

void buffer_init(){
     for(size_t i = 0; i < BUF_SIZE; i++)
          buffer[i] = 0;
     buffer_ready = 1;
}
```
簡単な関数の例なのですが、
> volatile宣言がされている場合、コンパイラはそのデータが置かれたメモリに対する読み書きの順序を変更できない。しかし、これらの読み書きと、他のメモリに対する読み書きとの順序を変更してもよい。
したがって、コンパイラはこのループをbuffer_readyへの書き込みの後に移動することができる。これはプログラマの意図に反する。

今回の場合は、buffer_readyが入れ替わっても問題無さそうですが、複雑な関数になると問題になってくるはずです。
そうすると、bufferの方にもvolatileを付ける羽目になり、**volatileがどんどん増えていきます。**

buffer_init()そのものを最適化抑止させる機能があると便利ではないでしょうか？

[ラムダ式って何が便利なのです？？](https://teratail.com/questions/110961)
以前の質問で、main()を内をさらに細かい関数単位で分割できる・・・と言ったんですが、すると関数の中もラムダ式を使って細かく最適化抑止を制御できるのではないか？（ラムダ関数を最適化抑止する）
という想像ができます。
ラムダ式の利便性が向上しそうです。
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

まぁ、私の妄想はどうでもいいんですけど・・・関数全体に対して最適化抑止機能が付いているのはどうかなぁ？？と思っただけの話なのです。

ここでの疑問は「**どうやって、volatile修飾が必要な箇所を見つければ良いんでしょうか？？**」という疑問です。
パターンがあるなら、是非教えてください。

volatileが必要な場面を見つけ出す

現在Twitter上のデータマイニングの過程でScikit-learnによる機械学習を用いて二値分類する識別機を作っています。識別機にテストデータを識別させた際に生じる不正解データがどのようなものなのかを知りたいのですがScikit-learnで便利な関数など無いでしょうか？
詳しい型宜しくお願いします。

【Python】Scikit-learnでの機械学習における不正解データの抽出【機械学習】

はじめまして。
python初心者になります。

現在python3でユニットテストを実装しており、
nosetestモジュールを用いているのですが、不可解な現象に悩まされております。
nosetestモジュールは'test'と命名されているディレクトリ、モジュールを
再帰的にテストしてくれると思っているのですが、してくれていない状況です。
(テスト対象モジュールを引数として渡すと実施してくれます。
またテストもOKとなるので、テスト対象・テスト対象コードは問題ないと考えております。)
そもそもnosetestモジュール自体、python3には未対応なのでしょうか？
(公式サイト上には対応していると書いてありましたが、いまいち英語に自信がなく。。)

下記に実行しているコマンドを記述します。
```
nodetests -s -v
```
また、バージョンは下記になります。

Python 3.6
nosetest 1.3.7

Python初心者のため、的外れな質問をしておりましたら申し訳ございません。
ご回答のほどよろしくお願いいたします。