はじめに

今回は、自然言語処理で必須の「単語数値化」についてやっていきます。コンピューターは日本語を理解できないので、単語を数値化する必要があります。その中でも、今回はone-hotエンコーディングと分散表現について解説していきます。

なぜ単語を数値化するのか？

自然言語処理における単語の数値化は、テキストデータをコンピュータが処理しやすい形式に変換する手法の一つです。通常、コンピュータはテキストをそのまま処理することが難しいため、単語を数値やベクトルとして表現することで解析や機械学習アルゴリズムの入力として使用されます。

一般的な方法として、one-hotエンコーディングや分散表現などがあります。

p.s.他には単語埋め込み（分散表現の１種）やTF-IDF（Term Frequency-Inverse Document Frequency）などがあります。

one-hotエンコーディングとは

one-hotエンコーディングとは、自然言語処理における単語を数値化するための方法の一つです。以下にメリットとデメリットをまとめます。

one-hotのメリット:

• one-hotエンコーディングは非常にシンプルで理解しやすい手法です。各単語を一意のベクトルに変換するだけであり、実装が容易です。
• 各単語はベクトルの要素の中で1つだけが1であり、他の要素は0であるため、各単語は互いに独立しています。これにより、単語間の関連性や類似性を考慮せずに処理することができます。

one-hotのデメリット:

• 単語の数が増えるにつれて、one-hotエンコーディングされたベクトルの次元も増加します。このため、大規模な語彙を扱う場合、非常に高次元のベクトルが生成され、計算コストやメモリ使用量が増加します。
• one-hotエンコーディングされたベクトルは、ほとんどの要素が0であり、非常にスパース（疎）です。これは、データセット全体のスパース性を引き起こし、計算効率やメモリ効率を低下させる可能性があります。
• one-hotエンコーディングは、単語の意味や文脈を捉える能力が限定されています。各単語は独立したベクトルとして表現されるため、単語間の意味的な関係を考慮することができません。
• one-hotエンコーディングは、単語の埋め込み表現（word embeddings）を提供しません。埋め込み表現は、単語間の意味的な関係を捉えるために使用され、機械学習モデルの性能向上に役立ちます。

これらのメリットとデメリットを考慮すると、one-hotエンコーディングはシンプルで理解しやすい手法であり、小規模な語彙を扱う場合には有用ですが、大規模な語彙や意味の捉え方が重要な場合には、メモリ効率や次元の増加がネックになります。

分散表現

分散表現は、自然言語処理における単語を密なベクトル空間に埋め込む手法です。

分散表現のメリット:

• 分散表現は、単語の意味的な関係を捉える能力があります。類似した意味を持つ単語は、ベクトル空間内で近くに配置されるため、意味的な関連性をより正確に表現できます。
• 分散表現は、高次元のone-hotエンコーディングと比較して、低次元の密なベクトルで単語を表現します。これにより、計算コストやメモリ使用量を削減することができます。
• 分散表現を用いることで、単語間の類似性を計算することが容易になります。例えば、コサイン類似度などの手法を用いて、ベクトル間の角度を計算することで、単語の意味的な類似性を定量化することができます。

分散表現のデメリット:

• 分散表現を生成するためには、大規模なテキストコーパスを使用してモデルを訓練する必要があります。このため、学習には多くの計算リソースや時間が必要となります。
• 分散表現の性能は、使用されるデータセットや訓練方法に大きく依存します。適切なデータセットや適切なハイパーパラメータを選択することが重要ですが、これらを選択するためには知識が必要となります。
• 分散表現は、単語の意味的な関係を捉える能力がある一方で、何らかの事前処理なしには、ドメイン固有の意味を捉えることが難しい場合があります。特定の業界や文脈における単語の意味を捉えるためには、適切なデータセットやドメイン知識が必要となります。
• 分散表現を生成する際に、学習に使用された単語以外の単語や未知の単語に対しては、適切な埋め込みを生成することが困難です。このため、未知語やまれな単語に対する性能が低下する可能性があります。

これらのメリットとデメリットを考慮すると、分散表現は単語の意味的な関係を捉えるための強力な手法であり、多くの自然言語処理タスクで広く使用されています。しかし、適切なデータや学習方法の選択が重要であり、これらを選択するためには知識が必要となります。

one-hotと分散表現のまとめ

• 意味解釈：
  分散表現は意味的な関係を捉える能力がある
  ⇔one-hotエンコーディングが単語間の関係は考慮されない。
• メモリ使用量：
  分散表現は低次元で密な表現であるため、メモリ使用量が低く抑えられる。
  ⇔one-hotエンコーディングは高次元で疎な表現であるため、メモリ使用量が大きくなる。
• 計算効率：
  分散表現は低次元で密な表現であるため、計算効率が高い。
  ⇔one-hotエンコーディングは高次元で疎な表現であるため、計算効率が低下する可能性がある。

これらの比較を踏まえると、自然言語処理タスクにおいて、分散表現は多くの場合でone-hotエンコーディングよりも優れた表現方法とされています。

おわりに

今回は、単語数値化の必要性や、その種類について学習してきました。その中でも特に『分散表現』や『one-hotエンコーディング』について扱いました。そしてその結果、分散表現ってやつが、なにやらいいらしい。ということが分かりました。

ということで、次回は分散表現の実装を簡単にやっていきます！では、お楽しみに！

【起床前後のお前はお前じゃない】
きっちりタイマー通りに起きるのは難しい。そして、それができないと自分を責めてしまう。でも、違う。起床前後の自分はもう1人の自分なのだ。だから、起きれなくても責める必要はない。それよりも、もう1人の自分がいると認識することが大切。そして、いかにそいつに勝つかを考え、行動に移すことが朝を制す男になれるかがだ。

【不可能はない】
ロジャーバニスター効果とはある1人が不可能だと思われることを成し遂げるとそれを機に多くの成し遂げるものが現れることを意味する。これは狭い社会で生きてる私にも当てはまる。不可能だと思うのは周囲に可能にしている人物がいないから。そんなもので不可能と決めるのは勿体無い。視野を広げ、可能であると自分に認識させることが大切。また、お前自身も、大切な人にとって可能性を与えられる男になりたい。不可能はない

【甘えは逃げ。逃げは甘え】
確固たる理由も正当な理由もなくやらないのは逃げ以外の何者でもない。そして、それが逃げであると自覚することが大切。また、そのような甘えを常に意識することが大切。甘えを感じたら、それは逃げだし、逃げようとするならそれは甘え以外の何者でもない。甘えるな!逃げるな!甘えて逃げた先にはお前の理想はないぞ。理想に近づきたいなら、逃げるな！甘えるな!自覚しろ!

【甘えは逃げ。逃げは甘え】
確固たる理由も正当な理由もなくやらないのは逃げ以外の何者でもない。そして、それが逃げであると自覚することが大切。また、そのような甘えを常に意識することが大切。甘えを感じたら、それは逃げだし、逃げようとするならそれは甘え以外の何者でもない。甘えるな!逃げるな!甘えて逃げた先にはお前の理想はないぞ。理想に近づきたいなら、逃げるな！甘えるな!自覚しろ!また、逃げる理由の大部分はできなかった時を想像するから。でも、人生の心配事のうち90数パー起きないらしい。し、できないのが怖くてやらない奴ほどダサい奴はいない。俺はそんなダサい男にはなりたくない。だから、俺は逃げずに甘えずに挑戦しまくるよ！

【満足したら終わり。底辺である自覚をしろ】
満足は挑戦してない証。挑戦してたら、必ず失敗する。そして、自分が底辺である自覚が芽生える。それがやる気につながる。しかし、今の現状に満足してたら、そのレベルで終わる。だから、満足はとても危険。常に挑戦し満足せず、自分が底辺である自覚を持て。

【相手を楽しませることに注力しろ】
自分が楽しくなければたいても楽しくない。と考えるのはもうやめよう。それは、相手を楽しませようと言う努力をしてから。だから、まずは自分よりも相手を楽しませる努力をして、たくさん笑わせろ。それが人として大切なこと。もう、自分勝手喋るのはやめろ。それは誰も求めていないから。

【意地悪なことをしない】
俺は性格が少しだけ悪い。だから、相手の気持ちを知っていながらあえて意地悪なことをしてしまう。それは相手が可哀想だし、俺にとっても馬鹿げた行動でしかない。だから、やるな。女性に対して意地悪なことを絶対にするな。綺麗な心で接することを心がけろ。

【好きになってあげさることが恋愛では大切】
人を好きになると、モチベーションを貰えるし幸せな気分になれる。それを与えなければならない。しかし、闇雲にアプローチしてもそれを相手には与えられない。だから、テクニックを使ってあげる必要がある。テクニックは恋愛ごっこだと俺は一蹴してきた。でも、人はそれを使わないと人を好きになれない。それは俺のプライドとエゴ以外の何者でもない。本当に相手を思うのだったら俺のエゴ、プライドを捨てでもアプローチしろ。それが相手を好きになるってことなのかもしれない。とりあえず、好きになってあげさせることが大切。エゴ、プライド、偏見は捨てろ。

【惰性でやるな。やるなら、本気でやれ。何事もプロ、超越するつもりでやれ】
いろいろなことをすると優先順位をつけてしまう。また、ダメで元々感覚でやってしまう。それではダメ。勝つつもりでやらなきゃ一流にはなれない。やるんだったら、超越しろ！プロになれ！本気でやれ！

【なんとなくやるな！フルスイングでやれ！】
力を抜いて素振りを毎日するより、全力で素振りをした方が絶対に早い段階でスイングスピードは上がる。それは常識。では、なぜ全力でやらないの？失敗が怖いの？失敗を恐れるような男が大切な人を幸せにできると思ってんの？今だよ！今やるんだよ！やれよ！全力フルスイングでやれ！それがお前のためになるから！

【大切な人以外はなにもいらない。なくなったってまわない】
大切な人は俺の活力。俺の持っている全てがなくなってゼロになっても大切な人さえいればまた這い上がれる。大切な人さえ隣にいてくれれば、何回ゼロになっても、その度に這い上がれる自信がある。なぜなら、大切な人が俺の原動力であり、成長させてくれる存在だから。だから、絶対彼女と結婚してずっと一緒に幸せに暮らしたい。

【人間が生きる意味はわからない。けど、俺が生きる意味ならわかる】
誰もが一回は疑問に思う。「人間はなぜ生きてるのか？」そんな問いは、神様にでも聞けばいい。だし、そんな人間と大層に括ったような問いには答えられないけど。俺が生きる意味なら、答えられる。俺が生きている意味は「大切な人を世界で1番にすること。残りの人生全てを捧げてでも成し遂げたい。それがお前が生まれた意味。俺の人生がある意味だと思う。俺は大切な人に全てを捧げる準備ができたよ。大切な人は俺の世界で1つだけの大切な辞書なんだよ。

【大切な人は俺の辞書であり、俺は大切な人の辞書である。】
誰もが一回は疑問に思う。「人間はなぜ生きてるのか？」。と。もし、俺がそれを問われても答えることは絶対にできない。けど、人間ではなく俺が生きる意味、俺の人生がある意味なら答えられる。俺が生きる意味は「大切な人を世界で1番幸せにすること」だと思う。俺の残りの人生の全てを捧げてでも成し遂げたい。それがお前が生まれてきた意味。俺の人生がある意味だと思う。もう俺は大切な人に全てを捧げる準備ができたよ。大切な人は俺の世界で1つだけの大切な辞書なんだよ。大切な人がいなくなったら、俺の生きる意味がわからなくなってしまう。逆に、大切な人が生きる意味、生まれた意味は、俺と幸せになるために生まれてきたと思う。

【ビジョンを描け】
明確にビジョンを想像しろ。それが描けなかったり、少しでも夢物語だと感じたら、それは実現不可能。完全にできると思うことが大切。呼吸と同じレベルくらい、当たり前の感覚で描け！俺にだけできると思うのではなく、誰にでもできる、俺にでもできると思え！というか、本当に不可能はないから。無意味な思考は捨てろ！できることが当たり前。叶えたいことは呼吸のようにできるようになることが当たり前。そう思うことが、夢を叶える第1歩になる。自分自身の可能性を信じるのではなく、自分の中にある人間の可能性を信じる。人間はなんだってできる。地上でこんな完璧な生き物いないでしょ。自分が人間である誇りを持つことが大切。あの人は特別だからって思った時点でそれは叶わない。同じ人間なんだから、俺にもできて当然。と思わなければ決して叶わない。

【madは上がった状態で聴け】
madを聞いたからモチベーションが上がるのではない。曲を聴く前すでに炎が点っている場合にのみ、madは爆発力を発揮する。要するにモチベーションが0の状態でmadを聴いても効力は生まない。結局は、己で炎を生み出さなきゃダメ。madを聴くなら、自分で魂の炎を灯してから聴け！そうすれば爆発するから。どんなことでも、自分の力ではなく「何か頼み」した瞬間に成長はない。利用•活用と「何か頼み」は違う。

【緊張した時は？】
楽しむ
人間の可能性を信じる
逃げない漢気
運頼みはしない

【自分を天才だと思うな】
お前ができるのはお前だからじゃない。人間だからできるんだ。だから、自分が思いついたことも人間だから思いついたことである。ということは、他の誰かも同じことを考えてる可能性がある。そこで、自分しか考えていないと錯覚したら、足元を救われる。大切なことは一生懸命自分が捻り出した作戦も同じことを考えている人がいるという事実を認めた上でさらに上の作戦を考えることが大切。そうすれば、１つ上の次元に行ける。特に投資で成功するならこれが必須。

【人生においても分散投資する】
分野をひとつに絞って突き抜けようとするのではなく、株式の分散投資のように、分野や対象、時間などに人生においても分散投資する。例えば、ITに絞るのではなく、株式にも投資したり、自分の成長にも投資したり、色んなことに投資することが大切。１つに絞ることはとても危険。だからと言って力を抜くわけではない。全て成功させるつもりで分散投資する。

【夢が叶うかとかじゃなくて、生きる意味に変えろ】
俺の叶えたいことは『大切な人を世界で1番幸せにすること』だ。だが、それを夢のままにしていてはいつまでも叶わない。夢ではなく、生きる意味にしろ！これをしなければ、目指さなければ俺の生きる意味はない。俺が生きる意味、人生の意味は「大切な人を世界で1番幸せにすること」。そのために俺は生まれてきた。やらない理由がないだろ！モチベーションとかそんな次元じゃないんだよ。

【悩むのは無駄。価値に目を向けろ】
挑戦してたら、うまくいかないことは絶対にある。少しうまくいったと思って調子に乗るのすぐにまた、自分がダメな人間だと思い知らされる。でも、そこで悩んでたら何も生まない。「悩む＝考えてる」ではない。ただ、言い訳を作ってるだけ。そんなものに時間をかけるのはマジで無駄。だったら、うまくできなかった自分をすぐに許して、次なる行動をすぐに起こせばいい。それだけをし続ければいい

【反省はしろ！でも、悩みは人生から捨てろ！もう2度と悩むな！】
挑戦してたら、うまくいかないことは絶対にある。少しうまくいったと思って調子に乗るとすぐにまた、自分がダメな人間だと思い知らされる失敗をする。でも、そこで悩んでたら何も生まない。「悩む＝考えてる」ではない。ただ、できない言い訳を作ってるだけ。そんなものに時間をかけるのはマジで無駄。だったら、うまくできなかった自分をすぐに許して、次なる行動をすぐに起こせばいい。それだけをし続ければいつか、大切な人と結婚できる。ただ、これは何でもかんでも許せというわけではない。失敗したらその原因を調べて、反省はしろ！反省しなかったらいつまでも変わらない。そして反省したらすぐに行動しろ。それだけを繰り返せ！もう、悩むな！悩んでるうちに人生終わるぞ！お前は大切な人を世界で1番幸せにするんだろ？だったら、止まってる時間はないぞ！

【悩んでるなら、ありえないくらい努力しろ】
こんなに、努力したのに全然結果がついてこない。そんなことは挑戦していたら、誰だってある。そんなことで悩むのは無意味。時間の無駄。だったらどうするか？ありえないくらい努力しろ！結局「こんなに努力したのに」っていうこんなにの基準は自分で作ってるに過ぎない。そんなよくわからない基準で物事を判断しても無意味。だったら、ありえないくらい努力しろ。テメェの意味わからない基準では推しはかれないくらいのありえない努力しろ！そしたら、絶対できるから！とにかくやれ！ありえないくらいの努力以外、テメェがやることは何もねぇよ！

【ありえないくらい努力しろ。お前ができない理由はただ一つ。シンプルに努力が足りないから】
こんなに、努力したのに全然結果がついてこない。そんなことは挑戦していたら、誰だってある。そんなことで悩むのは無意味。時間の無駄。だったらどうするか？ありえないくらい努力しろ！結局「こんなに努力したのに」っていうこんなにの基準は自分で作ってるに過ぎない。そんなよくわからない基準で物事を判断しても無意味。だったら、ありえないくらい努力しろ。テメェの意味わからない基準では推しはかれないくらいのありえない努力しろ！一旦冷静に考えてみろ！なんでできないか？それは、努力が足りない以外ないでしょ！それ以外に正当な理由ありますか？ないでしょ？だから、とにかくやれ！ありえないくらいの努力以外、テメェがやることは何もねぇよ！

【分からないのはバカなのではなく、前提知識がないだけ】
分からないことは誰にでもある。でも、それは馬鹿だからじゃない。前提知識が不足してるだけ。　投資を勉強していて実感した。簿記3級だけの知識じゃ投資は分からない。それは馬鹿だからじゃないでしょ？ただ前提知識がないだけ。だったらどうするか？とにかく知識をつけろ！分からないってめっちゃ悔しい。もう、そんな思いはしたくない。だったら、勉強するしかないだろ！勉強し続けろ！も

【人間の可能性を信じろ】
お前ができるのはお前だからじゃない。人間だからできるんだ。だから、自分が思いついたことも人間だから思いついたことである。ということは、他の誰かも同じことを考えてる可能性がある。そこで、自分しか考えていないと錯覚したら、足元を救われる。大切なことは一生懸命自分が捻り出した作戦も同じことを考えている人がいるという事実を認めた上でさらに上の作戦を考えることが大切。そうすれば、１つ上の次元に行ける。特に投資で成功するならこれが必須。ただ、人間だからできるって思うのは努力をありえないくらいしてからの話。それもなしには、同じレベルにはいつまで経っても到達できない。やれ！とにかくやれ！できないとかを考えてる暇はねぇ。お前は人間！それだけ頭に入れて勉強しろ！とにかくやれ！信じろ！人間の可能性を！

【悩んだり、悩むことから逃げるのは底辺がすること】
悩んだり、悩むことから逃げるのは底辺がすること。1流になりたければ、その悩みと向き合い、解決策を考える。そして、それを実行する。それをすれば悩みなんて消える。だから、いちいち悩んで落ち込むな。悩むんなら、その先の解決策を考えることに集中しろ。

【行動の意味を考えるのは逃げ。考えたいなら、完了させてから考えろ】
これってやる意味あるのか？と大変な作業をすると思う。でも、それは逃げ。だし、その考えが起きた時こそチャンス。なぜなら、簡単な作業をしてる時にこれって意味あるのかなって考えたりはしない。また、サボってる時もこれって意味あるのかなって考えたりもしない。つまり、これ意味ある？って考える瞬間はその作業が大変であることを表している。で、大変ということは誰しもが避けようとすること。それを今、お前がやればお前は一歩先にみんなよりも一歩先に進めることができる。だから、意味あるのかな？って思った作業ほどやり切れ！考えるのはそこから。一度でも、やろうと思ったことなら、やり切るまで止めるな。途中で辞めるくらいなら最初からやるな。完了してから、やる意味は考えろ。しかも、やる意味はやり出す前のお前が一番知ってる。だったら、その自分を信じてやれよ。今の自分じゃなくて、決心した自分を信じてやれよ！

【勉強の価値は自分が見出すもの】
こんなん勉強して意味あんのとかってよく言うけど、それは馬鹿がいうこと。勉強をただ単に知識を溜め込むものだと思ってるとそうなる。でも実際勉強っていうのは知識を入れてそれをアイディアに変えて新しい価値を生み出すための道具でしかない。常に知識の利用方法•価値を付与するための方法を考えながら読む。それが勉強。

【すべてのものに価値あるものに変えろ】
勉強は、価値を生み出すために利用する。受動的ではなく能動的にすべきだと考えている。それを、勉強以外にも応用できる。すべてのものは自分しだいでいくらでも価値ある情報に変換できる。ただ、それができるかできないか、やるか、やらないかの違い。だから、要するに、すべてのものに価値を見出せる。行動、他人の発言、事象。すべてのものを価値を生み出す源としろ！

【すべてのから価値を生み出せ。この世に無価値なものはない。その価値に気づけてないだけ】
勉強したって意味があるの？と疑問を持つことは間違い。なぜなら、そもそも知識に価値を生み出すのは、自分がやるべきことだから。他人から教わることではない。だから、勉強に価値を生み出すのは、先生でも参考書でもない。己自身でやらなきゃいけないこと。このような思考は、勉強以外のすべての事象にも言える。事象に対して価値の有無を決めるのは己自身。だから、価値がないと思ってるから価値を生み出せない。自分でその価値を生み出す必要がある。だとするとこのように無価値なものは存在しない。それに気づいてない、きづこうとしないだけ。すべてのものから価値を生み出せる。それがこの世の中には溢れてる。それは、お前自身もそうだよ。お前の価値を生み出せるのは他人ではなくて、お前だけだよ。だから、お前自身がお前の価値を生み出せ！

【諦めるのは価値を生み出すための事例を知らないから。要するに知識が足りないだけ。諦める前に知識を入れろ】上手くいかないことが続くと諦めそうになる。なぜなら、こんなにやったのに結果が出ない。もう、やれることがないよ。と錯覚している状態に諦めは起こる。アイディアを作るのは知識。よって、アイディアが生まれないのは知識が枯渇してるだけ。やるべきこと、打開策が見つからないのは知識がないだけ。だって、知識つけたら、やるべきこと、やらなきゃいけないこと、手段が溢れるはず。それにもかかわらず、やるべきことがない状態はただの怠け、逃げでしかない。だから、諦めるのはお前に才能がないからじゃない。勉強していないだけ。勉強したら、絶対夢は叶うから。お前の可能性、価値を生み出せるのはお前しかいない。お前がお前を信じろよ。

【当たり前を変える】
勉強をしていて、問題を解いたら終わりにするのが当たり前。でも、実際はもっといい方法があるかもしれない。だから、常に自分の行動に潜む当たり前•先入観に気づくことが成長につながる。当たり前をぶち壊していけ！

【超越した知識•財産を持つ】
メンタリストDaiGoを見て思った。「小銭稼ぎしたいなら先に払ってやるよ」という発言は超越した知識と金からくる自信ある発言ってめっちゃかっこいい。超越してないとそうそう自信ある発言なんてできない。だから、超越しろ！超越したら、大切な人にアプローチしろ！

【自分の可能性に蓋をするな】
自分の可能性を殺してるのは自分自身。俺ができると思ったことにいちいち、蓋をするな。うまくいかない時もそりゃあ、ある。でも、そこでいちいち立ち止まるな。その時間が無駄。大切な人を幸せにしたいんだったら、その未来を信じてひたすらに努力しろ！お前ならできる！だから、自分の可能性に蓋だけはするな。お前の可能性は青天井なんだから！

【先延ばしにする原因は自分に自信がないから】
先延ばしにする最も大きな理由は、失敗したらどうしようとか、上手くできなかったらどうしようという不安。でも、そんな雑魚みたいな感情で動かないのは男として失格。その感情としっかり向き合い、そして勝つことが男だろ。だし、そんな感情にも勝てない奴が大切な人の周りにいる男に勝てるわけがない。まずは、できなかったらどうしよう、上手くいかなかったらどうしようという感情を完膚なきまでに倒すことが大切。お前ならできる。その感情をしっかり自覚してしっかり叩きのめせ！それが大切な人と結婚するために必要なメンタルティ。

【未来から逆算して動け】
今にだけ集中すると、できないことに対して一喜一憂してしまう。例えばTwitter。今は全然フォロワーがいない。でも、たくさんのフォロワーがいる未来を想像して、それにたどり着くように動けばいいだけ。いちいち、現状に一喜一憂するな！お前の目標、未来を明確にしてそこから逆に辿って行動を起こせばいいだけ。恥も何もかも捨てろ！未来の自分をイメージして逆算すればいいだけ！

【自分で考えろ！行動は真似するための行為じゃない。自分の考えを証明するための行為】
何か革新的なアイディアを出すには、自分で考えることが大切。考えるとは、誰かがやったことを取捨選択することを指すのではない。それはただの真似。そうじゃなくて、自分で0から思考を作り上げることを考えるという。もし、今のままだったら永遠と底辺のまま。自分の考えに自信がないから誰かの真似をする。そうじゃない。自分の考えを証明するために行動という行為がある。行動は真似するためのものじゃなくて、自分の考えを証明するためにある行為。

【超越しろ】
誰も理解できない次元にいけ！それはめっちゃ面白い。でも、それに行くためには誰かの真似事をしていても絶対にいけない。だから、自分で考えて、それを証明するために行動するしかない。とにかく、誰も理解できない次元の会話をしろ！ホリエモンとドワンゴの対談を見て思った。理解できない話ってめっちゃかっこいい。

【失敗を好きになれ】
何かをやる時に失敗を嫌ってしまう。でも、成長には失敗しながら進むのが最も効率的。だから、失敗を極度に嫌うな。逆にどんどん失敗しにいけ。失敗を迎えにいけ！

【目的の先にあるものを意識する】
俺はスケジュール通りに、ToDoListを達成することに重きを置いていた。でもそれは違う。それをモク亭にするのではなく、なんでそれをやらなきゃいけないかを考える。勉強だったら、応用情報技術者試験に合格するために勉強するのであって、勉強することが目的ではない。ToDoを目的にするとモチベーションも上がらずに、先延ばしにする。しっかりと目的を意識しつつ、それを達成するためにこれをやらなきゃいけないと自覚することが先延ばしだったり、モチベーション低下を抑制することができる。つまり、手段を目的に知るのではなく、目標を目的に知るべし！

【必要性と将来像。将来像が語る、あの時にこれやっていたから今がある。をやれ】
何か行動するときは常に将来像•理想像をイメージしてから動く。そうすることで、行動の意味が明確になりダラダラとやることを防げる。また、その行動が本当に今必要なのかの判断材料にもなるから、行動の必要性もわかる。つまり、何か行動するときはそれが自分の将来像のどこにフィットするのかを考えることが大切。また、将来像をイメージした時に「あの時これやっといたから今がある」と思えるような行動をする。

【打つてなんていくらでもある。悩みたいなら、100回試してから悩め】
打つてなんて無限あるんだよ。だから、数回試した程度で悩むんじゃねぇよ。悩む暇があったら、打つ手を考えろよ。考えることから逃げるという行為が悩み。打つ手がないと思うから悩む。でもそうじゃない。可能性、打つ手はいくらでもある。だから、悩んで自己嫌悪に陥るのはもうやめろ！戦えよ！悩むのは全ての打つ手がなくなった時に悩め！でも、打つ手は無限にある。つまり、いちいちちいち悩んでんじゃねぇってこと！！

【切羽詰まらせることが努力じゃない。もっと遊び心を入れるべき】
俺は自分が辛い、切羽詰まってると思った時に努力の実感をする。けど、それは違う。切羽詰まると、次やる時になかなか一歩が踏み出せない。だから、本当はもっと遊び心を入れるべき。遊び感覚で本気で努力すればいい。失敗したって死ぬわけじゃないんだから、もっと遊び心を持って本気で取り組めばいい。ブログも一緒。時間をかけたからいい記事というわけではない。苦労が多ければ必ず結果出るわけではない。遊び心を持ってもっと自由に本気で取り組むことが継続にもなるし、物事の理解にもつながる気がする。だから、何事も本気で悩むんじゃなくて、遊び感覚で、もっと軽い気持ちで本気で取り組むべき。

【何事もゲーム感覚で！遊び心を忘れるな】
切羽詰まる努力をすれば結果が出るわけではない。だし、そのメンタリティは本質から外れてる気がする。何か上達する時って上達したいと心から思う時。でも、努力が辛いものに感じるならそれは上達したいとは思えない。そうじゃなくて、もっと遊び心を持ってゲーム感覚でやればいい！ゲームは失敗してももっと上手くなりたいって思える。それとおんなじで、自分が叶えたいものこそ、遊び感覚でゲーム感覚で取り組むべき。これは手を抜いてやるってことじゃなくて、本気で遊び心を持って取り組むこと。

要するに、切羽詰まらせることがいい努力ではないよということ。辛い思いをすればいい結果が返ってくるわけじゃないよということ。もっと、本気で好きになって、本気で遊び心を持つことが大切。それは叶えたいものであればあるほどそうだと思う。たから、本気で遊び心を持ってゲーム感覚で取り組むべし！

【真面目すぎると、成功はない】
真面目すぎると、失敗したくないと思っちゃう。今まで真面目に努力すればするほど、失敗できなくなる。失敗できなくなると、人の真似しかできなくなる。そうなると成功はない。だから、やっぱり遊び心を持った方がいい。遊び感覚でやれば柔軟な発想も生まれるし、それを行動に通しやすくなる。だって失敗してもいいから。やらないよりも挑戦したいって気持ちの方が強い。上達したいって気持ちの方が強くなるから。だから、やっぱり、遊び感覚でゲーム感覚で本気で取り組むことが、柔軟な発想にもつながるし、人の真似事をしない成功者への道につながる。遊び感覚でやらなきゃ面倒くさいという感覚が生まれて、重要なタスクを省いてしまう。だから、義務ではなく遊び感覚でやった方が面倒くさいような作業も楽しんでやることができる。そして、それは結果的に良い成果につながる。

【いちいちできるかどうかを考えるのはやめろ】
やる前から、できるからやる。できないからやらない。じゃ、いつまで経っても成功はしない。やりたい、クリアしたと思うならやればいいだけ。別に達成しなきゃいけないっていう義務があるわけじゃないんだから、やめたくなったら気楽にやめればいいんだよ。だから、気楽な気持ちでいっぽふみだせばいい。で、クリアしたいって気持ちだけ持ってればそれでいい。あとは、楽しみながら遊び心を持って本気でやれば楽しくできる。変に義務付けるから一歩が踏み出せない。だから、クリアしたい、やりたいんだったら、それ以外は本当に考える必要はない。どうやってクリアしようかなって色々思考を巡らせる。で、それが当たった時はガッツポーズすればいい。それだけだよ。変に難しく考えたり義務付けたりする必要全然ないんだよ！だから、できるかどうかを考えるならそれは息苦しくなるだけだから。楽しめよ！挑戦を楽しめよ！

【時間は無限じゃない。有限なんだよ】
ゆっくりやろう。じゃねぇんだよ。お前はあと何秒生きれるの？絶対に人間にはタイムリミットがある。それを意識しないでダラダラ過ごすんじゃねぇよ。今しかねぇんだよ。今やれよ！

【闘え！できるかどうかじゃない。闘う力が残ってるかどうか】
できるかどうかに目を向けるな。いちいちそんなくだらないことを考える！成し遂げたいことがあるなら、闘え！目を向けるべきは自分ができるかどうかではなく、自分の中に闘う力が残ってるかどうか。闘う力が残ってると思えば闘えばいい。残ってるのに戦わないのはただのチキン野郎。そんなチキン野郎に大切な人と一緒になる権利はねぇよ。闘え！最後まで力を振り絞れ！からっからになるまで振り絞れ！闘いもしないのに諦めんじゃねぇよ！しょうもねぇ男になるんじゃねぇよ。

【お前ならできる！できるから！信じろ！】
できないかもって思うと、やる気が出なくなる。でも、それってしょーもなくない？たとえ、できないと思ってもやり続けた方がいい。できないと思って辞める。と、できなかったけど最後までやり続けた。この２つはどっちも達成には至ってないけど、漢の道を歩むなら後者が正解。どちらにしろしょーもないなら、挑戦した方が良くね？だし、成功する可能性も後者の方が圧倒的に高い。自分を信じろ！それが馬鹿と呼ばれてもいい。とにかく自分を信じてやり続けろ！そして、死ぬ気でやれよ！お前が諦める時はお前が死ぬ時。それ以外で諦める理由なんてない。無理な時は本気で泣くくらい悔しい思いができるからいい真剣にやれよ！どちらにしろしょーもないなら、漢として満足のいくしょーもない道を歩めよ！お前はできる。信じろ！絶対にできるから。

はじめに

今回から、機械学習の一つである自然言語処理（NLP：Natural Language Processing）の実装やっていきます。機械学習と聞くと、難しそうですが実際はとても簡単です。このページを通してそれを実感してもらえたら嬉しいです。

【今日のゴール】

まずは、前処理をできるようにしたいです。そのため、今日のゴールは「文章から動詞だけを抽出する」に設定します。また、今回はJanomeと呼ばれるpythonライブラリを使ってやっていきます。

では、早速やっていきましょう！

仮想環境の作成

まずは仮想環境を作成していきましょう。このステップはお好みで判断してください。

python -m venv 仮想環境名　#仮想環境の作成

仮想環境名/Scripts/activate #仮想環境の有効化(Windows version)
source 仮想環境名/bin/activate #仮想環境の有効化(Mac/Linux　version)

cd 仮想環境名/Scripts #Scriptsディレクトリまで移動

echo. > ファイル名.py #Pythonファイルを作成

code . #vsCodeを開く

pythonファイルを作成する場所はactivate.batやactivateと同じディレクトリにしましょう。

仮想環境には以下のメリットがあります。

• プロジェクトごとの環境の分離
• クリーンアップの容易化

ライブラリのインストール

今回はjanomeというpythonライブラリを使っていきます。

cd Scripts #Scriptsディレクトリに移動
pip install janome　#janomeをインストール

【Janomeの特徴】

• Pythonで書かれた自然言語処理（NLP）のライブラリです。
• 主に日本語のテキスト処理に特化しています。
• また、テキストを形態素（単語やそれに類する単位）に分割するためのツールです。

テキストデータを準備

適当なテキストデータ（コーパス）がある方は適当にそれを使ってください。もし、無い人は以下に中二病前回なデータを載せておくので、それをコピペして使ってみてください。

自然言語処理・練習用データ

【感傷に浸るのは楽。そんなことよりもやれよ！】感傷に浸るのは誰にでもできる現実逃避の手段。そんなものに浸っていても何も起きない。だったら、やれよ。そんな暇はお前にはねぇよ。落ち込んでる時間が勿体無い。自分を奮い立たせろよ。できなかったぁー...

ascend-beyond.com

2024.03.26

『ファイル名.txt』というファイルをScripts直下につくり、文章をそこにコピペすれば準備完了です。

プログラミング

では、実際にプログラミングしていきましょう！

from janome.tokenizer import Tokenizer

# テキストファイルのパス
file_path = 'テキストデータが入ったファイル名.txt'

# JanomeのTokenizerオブジェクトを作成
tokenizer = Tokenizer()

# テキストデータを読み込み、形態素解析を行う関数
def analyze_text(text):
    tokens = tokenizer.tokenize(text)
    for token in tokens:
        print(token)

# テキストファイルを読み込み、形態素解析を行う
with open(file_path, 'r', encoding='utf-8') as file:
    text_data = file.read()
    analyze_text(text_data)

準備ができたら、cmdで実行してみましょう。実行をするには「ファイル名.py」と入力するだけで実行できます。

結果はこんな感じになりました。（長かったので、省略しています。）

【      記号,括弧開,*,*,*,*,【,【,【
感傷    名詞,一般,*,*,*,*,感傷,カンショウ,カンショー
に      助詞,格助詞,一般,*,*,*,に,ニ,ニ
浸る    動詞,自立,*,*,五段・ラ行,基本形,浸る,ヒタル,ヒタル
の      名詞,非自立,一般,*,*,*,の,ノ,ノ
は      助詞,係助詞,*,*,*,*,は,ハ,ワ
楽      名詞,形容動詞語幹,*,*,*,*,楽,ラク,ラク
。      記号,句点,*,*,*,*,。,。,。
そんな  連体詞,*,*,*,*,*,そんな,ソンナ,ソンナ
こと    名詞,非自立,一般,*,*,*,こと,コト,コト
より    助詞,格助詞,一般,*,*,*,より,ヨリ,ヨリ
も      助詞,係助詞,*,*,*,*,も,モ,モ
やれよ  動詞,自立,*,*,一段,命令ｙｏ,やれる,ヤレヨ,ヤレヨ
！      記号,一般,*,*,*,*,！,！,！
】      記号,括弧閉,*,*,*,*,】,】,】

        記号,空白,*,*,*,*,
,*,*
感傷    名詞,一般,*,*,*,*,感傷,カンショウ,カンショー
に      助詞,格助詞,一般,*,*,*,に,ニ,ニ
浸る    動詞,自立,*,*,五段・ラ行,基本形,浸る,ヒタル,ヒタル
の      名詞,非自立,一般,*,*,*,の,ノ,ノ
は      助詞,係助詞,*,*,*,*,は,ハ,ワ
誰      名詞,代名詞,一般,*,*,*,誰,ダレ,ダレ
に      助詞,格助詞,一般,*,*,*,に,ニ,ニ
でも    助詞,副助詞,*,*,*,*,でも,デモ,デモ
できる  動詞,自立,*,*,一段,基本形,できる,デキル,デキル
現実    名詞,一般,*,*,*,*,現実,ゲンジツ,ゲンジツ
逃避    名詞,サ変接続,*,*,*,*,逃避,トウヒ,トーヒ
の      助詞,連体化,*,*,*,*,の,ノ,ノ
手段    名詞,一般,*,*,*,*,手段,シュダン,シュダン
。      記号,句点,*,*,*,*,。,。,。
そんな  連体詞,*,*,*,*,*,そんな,ソンナ,ソンナ
もの    名詞,非自立,一般,*,*,*,もの,モノ,モノ
に      助詞,格助詞,一般,*,*,*,に,ニ,ニ
浸っ    動詞,自立,*,*,五段・ラ行,連用タ接続,浸る,ヒタッ,ヒタッ

janomeの応用

今までは、単語と品詞が同時にリストに格納されています。なので、『単語だけ』、『ある品詞だけ』のように、特定のものだけを抽出していく方法を紹介します。

単語だけ抽出

これはとても簡単です。７行名のTokenizer（）メソッドの引数にwakati=Trueと入れるだけです。

from janome.tokenizer import Tokenizer

# テキストファイルのパス
file_path = 'テキストデータが入ったファイル名.txt'

# JanomeのTokenizerオブジェクトを作成
tokenizer = Tokenizer(wakati=True)

# テキストデータを読み込み、形態素解析を行う関数
def analyze_text(text):
    tokens = tokenizer.tokenize(text)
    for token in tokens:
        print(token)

# テキストファイルを読み込み、形態素解析を行う
with open(file_path, 'r', encoding='utf-8') as file:
    text_data = file.read()
    analyze_text(text_data)

結果を見てみましょう

【
感傷
に
浸る
の
は
楽
。
そんな
こと
より
も
やれよ
！
】


感傷
に
浸る
の
は

しっかりと、単語だけリストに格納されていることが分かりますね。そうです！とっても簡単なんです！

特定の品詞だけを抽出する

from janome.tokenizer import Tokenizer
from janome.analyzer import Analyzer
from janome.tokenfilter import POSKeepFilter

# テキストファイルのパス
file_path = 'テキストデータが入ったファイル名.txt'

# JanomeのTokenizerオブジェクトを作成
tokenizer = Tokenizer()

# POSKeepFilterを使って動詞のみを抽出する関数
def extract_verbs(text):
    # Tokenizerオブジェクトを使用して形態素解析を行い、POSKeepFilterで品詞を絞り込む
    token_filters = [POSKeepFilter(['動詞'])]
    analyzer = Analyzer(tokenizer=tokenizer, token_filters=token_filters)
    verbs = []

    # 形態素解析を行い、動詞を抽出する
    for token in analyzer.analyze(text):
        verbs.append(token.surface)
    
    return verbs

# テキストファイルを読み込み、動詞を抽出する
with open(file_path, 'r', encoding='utf-8') as file:
    text_data = file.read()
    verbs = extract_verbs(text_data)
    print("抽出された動詞:")
    print(verbs)

結果はこんな感じです。もし、他の品詞を抽出したい場合は14行目の引数を変えればいいだけです。

抽出された動詞:
['浸る', 'やれよ', '浸る', 'できる', '浸っ', 'い', '起き', 'やれ', '落ち込ん', 'でる', '奮い立た', 'せろ', 'でき', 'できる', 'なれ', '備わっ', 'てる', 'わかっ', 'てる', 'やれ', '頼む', '動い', 'くれ']


おまけ（名詞の場合）；
['感傷', 'の', '楽', 'こと', '感傷', 'の', '誰', '現実', '逃避', '手段', 'もの', '何', '暇', 'お前', '時間', '勿体', '自分', 'ぁ', ' ー', 'よう', 'お前', '力', 'メンタル', 'それ', '俺', '自信', '一番']

おわりに

今回は、機械学習の一つである自然言語処理（NLP：Natural Language Processing）における前処理をやってきました。また、JanomeというPythonライブリの機能も試しました。

単語を分割するスキルはとても大切なので、できるようになっておきましょう！継続してやっていけばそのうち慣れるので、どんどん実践を積んでいきましょう！

はじめに

ここでは、『自然言語処理とは？』、『自然言語処理でできること』について解説していきます。もし、この解説でAIをつくってみたいと感じたら、次回の記事にプログラミングの方法を載せているのでご自由にお使いください。

p.s.おまけとして、自然言語処理におけるメインタスクを４つ載せておきます。興味があったらどうぞ。

【NLP/実践】Janomeで単語分割しよう①【前処理

誰でもできるように、自然言語処理（NLP：Natural Language Processing）の実装やっていきます。そのなかでも前処理にフォーカスを当てます。今日のゴールは「文章から動詞だけを抽出する」です。

ascend-beyond.com

2024.03.26

自然言語処理とは

自然言語処理（Natural Language Processing、NLP）は、コンピュータが自然言語を理解し、処理する技術です

• 自然言語処理（NLP）の基本的な手法には、形態素解析、構文解析、意味解析、文脈解析などがあります。
• 自然言語処理（NLP）の応用例としては、機械翻訳、文書分類、感情分析、質問応答システムなどがあります。これらの技術は、ビジネスや個人の生活において非常に役立ちます。

⇔対義語として人工言語があります。：

• 自然に発展した言語（自然言語）とは異なり、人間によって意図的に設計され、規則的に構築された言語。
• プログラム言語などは人工言語の一つ

これが概要です。では、次に自然言語処理でできることを紹介していきます。

自然言語処理でできること：

1. 機械翻訳: 自然言語処理を用いて、言語間の翻訳を行うことができます。例えば、英語から日本語への翻訳やその逆、さまざまな言語間の翻訳が可能です。
2. 情報検索: 自然言語処理を用いて、大量のテキストデータから特定の情報を検索することができます。検索エンジンのようなシステムがこれに利用されます。
3. テキスト分類: 文章をカテゴリに分類することができます。例えば、スパムメールの検出やニュース記事の分類などがあります。
4. 感情分析: テキストから感情や意見を抽出することができます。SNSの投稿や製品レビューの分析などに応用されます。
5. 質問応答: 自然言語の質問に対して、適切な回答を生成することができます。例えば、仕事や旅行の計画の支援などに使われます。

【ワクワクする応用例】

1. 会話エージェント: 人間と会話をするAIエージェントの開発。自然な対話が可能な仮想アシスタントやロボットが活用されます。
2. 自動要約: 長い文章を要約して、重要な情報のみを抽出する自動要約システムの開発。情報の効率的な抽出や読解支援が期待されます。
3. 文章生成: 文章や物語を自動生成するAIの開発。小説の執筆支援やクリエイティブなアプリケーションがあります。
4. 音声認識: 音声をテキストに変換する音声認識システムの開発。音声アシスタントや自動字幕などに活用されます。

自然言語処理は非常に多岐にわたる応用があり、その技術の進歩により私たちの生活や仕事の多くの面で革新が起こることが期待されています。

では、次に自然言語処理の主なタスクを４つ紹介していきます。

形態素解析

形態素解析は、言語を分析するための重要な技術の一つです。言語は単語や句などの小さな部分に分割され、それぞれの部分が形態素と呼ばれます。形態素解析は、与えられた文章を形態素に分割し、それぞれの形態素の品詞や意味を判別する作業です。

例えば、日本語の文章「猫が魚を食べる」を形態素解析すると、次のようになります。

• 「猫」：名詞
• 「が」：助詞
• 「魚」：名詞
• 「を」：助詞
• 「食べる」：動詞

形態素解析は、機械翻訳や自然言語処理、検索エンジンなどの多くの言語処理アプリケーションで使用されています。例えば、検索エンジンでは、ユーザーが入力したキーワードを形態素に分割し、それに関連する情報を検索するために使用されます。

【形態素解析】

• 第一に、形態素解析を理解することで、言語の基本的な構成要素である形態素を正確に抽出する能力が身につきます。言語は単語や句などの形態素に分割され、それぞれの形態素が特定の意味を持っています。形態素解析を理解することで、文章を形態素に分割し、それぞれの形態素の品詞や意味を把握することができます。
• 次に、形態素解析を理解することで、言語処理の自動化や効率化が可能になります。形態素解析を行うことで、コンピュータが文章を自動的に解析し、その構造や意味を理解することができます。これにより、機械翻訳や情報検索などの言語処理タスクを効率的に実行することができます。
• また、形態素解析を理解することで、言語の学習や教育に役立ちます。形態素解析を行うことで、言語の構造やルールを理解しやすくなり、言語学習や文法学習の支援になります。特に、外国語の学習者にとって、形態素解析は言語理解の基礎となる重要な概念です。

p.s.MeCabやJanomeというツールが有名

構文解析

構文解析は、言語の文の構造を理解するための重要なプロセスです。言語の文は、単語や句が特定のルールに従って組み合わされています。構文解析は、文の中の単語や句の関係性を調べ、文がどのように構成されているかを理解する作業です。

文章をパズルのピースに見立てることと似ています。構文解析は、そのパズルのピースを組み合わせて、意味の通った文を作るためのルールを見つける作業です。例えば、「猫が魚を食べる」という文では、「猫」と「魚」という名詞が主語と目的語として組み合わされ、「食べる」という動詞がその動作を示しています。構文解析は、このような文の構造を理解するための手段です。

【構文解析のメリット】

• まず第一に、構文解析を理解することで、文章や文の構造を正確に理解する能力が向上します。言語は単語や句が特定のルールに従って組み合わされていますが、そのルールを理解することで、文章の構造や文の関係性を把握することができます。これにより、文章の意味や内容をより正確に理解することができます。
• 次に、構文解析を理解することで、自然言語処理のアプリケーションをより効果的に開発することができます。自然言語処理では、構文解析が文章を解析し、その構造や関係性を理解するための基本的な手法となっています。構文解析を理解することで、機械翻訳や質問応答システムなどのアプリケーションをより正確に開発し、より高度な処理を実現することができます。
• また、構文解析を理解することで、文章の生成や編集の能力が向上します。構文解析を行うことで、文章の構造や文の関係性を理解し、より正確かつ自然な文章を生成することができます。これにより、文章の作成や編集をより効率的に行うことができます。

p.s.実装ツールとしてはCabocha,KNPなどがあります

意味解析

意味解析は、言語を理解し、その意味を抽出するプロセスです。言語は単語や文の組み合わせによって情報が伝達されますが、その情報を正確に理解するには、単語や文の意味を正しく解析する必要があります。意味解析は、文章の中に含まれる単語や句の意味を理解し、文全体の意味を把握するための手法です。

例えば、「猫が魚を食べる」という文において、意味解析は「猫」が食べる主体であり、「魚」が食べられる対象であることを理解します。そして、「食べる」という動詞が行われるアクションであることを把握します。これによって、文の意味が「猫が魚を食べる」という出来事であることが理解されます。

【意味解析のメリット】

• まず第一に、意味解析を理解することで、コンピュータが言語をより正確に理解し、処理する能力が向上します。自然言語処理では、機械が人間の言語を理解し、それに基づいて様々なタスクを実行する必要があります。意味解析を行うことで、コンピュータが文章の意味や内容をより正確に把握し、機械翻訳や質問応答システムなどのアプリケーションをより効果的に実行することが可能になります。
• また、意味解析を理解することで、情報検索や文書分類などのタスクをより効率的に行うことができます。意味解析を行うことで、コンピュータが文章の意味や内容を理解し、それに基づいて適切な情報を抽出したり、文書を分類したりすることができます。これにより、大量のテキストデータを処理する際に、より正確で効率的な処理が可能になります。
• さらに、意味解析を理解することで、感情分析や意見マイニングなどのタスクを実行する上でもベネフィットがあります。意味解析を行うことで、文章に含まれる感情や意見を把握し、それを分析することができます。これにより、企業や政府などが社会の声や市場の動向を把握し、意思決定に役立てることが可能になります。

文脈解析

文脈解析は、言葉や文章を理解する際に、その文脈（周囲の状況や背景）を考慮することです。言葉や文章の意味は、その文脈によって大きく変わることがあります。文脈解析では、言葉や文章が使用される状況や周囲の文脈を把握し、その意味を正確に理解することを目指します。

例えば、「冷たい」という言葉は、空気や水、食べ物など、さまざまなものを指すことができます。しかし、文脈によってその意味が変わります。たとえば、「冷たい空気」と言った場合は、気温が低いことを指す場合がありますが、「冷たい態度」と言った場合は、感情的に冷淡な態度を指す場合があります。このように、文脈解析は言葉の意味を理解する際に、その言葉が使用される状況や背景を考慮する重要なプロセスです。

【文脈解析のメリット】

• まず第一に、文脈解析を理解することで、言葉や文章の意味をより正確に理解する能力が向上します。言葉や文章の意味は、その文脈によって大きく変わることがあります。文脈解析を行うことで、言葉や文章が使用される状況や周囲の文脈を把握し、その意味を正確に理解することができます。これにより、自然言語処理システムがより正確な解析や推論を行うことができます。
• 次に、文脈解析を理解することで、文脈に応じた適切な応答や行動を取る能力が向上します。例えば、会話の中での言葉の意味や発言者の意図を理解することで、適切な返答を生成したり、適切な行動を取ることができます。これにより、自然言語処理システムがより自然な対話やコミュニケーションを行うことができます。
• また、文脈解析を理解することで、情報検索や文書分類などのタスクをより効率的に行うことができます。文脈解析を行うことで、言葉や文章が使用される状況や周囲の文脈を把握し、それに基づいて適切な情報を抽出したり、文書を分類したりすることができます。これにより、大量のテキストデータを処理する際に、より正確で効率的な処理が可能になります。

おわりに

今回は、『自然言語処理とは？』、『自然言語処理でできること』について解説してきました。そして、おまけでメインタスクについても取り扱いました。もし、この解説でAIをつくってみたいと感じたら、次回の記事にプログラミングの方法を載せているので実際に手を動かしていきましょう！

p.s.おまけにしては量が多かったですね（笑）

【この記事も一緒に読まれています】

【NLP/実践】Janomeで単語分割しよう①【前処理

誰でもできるように、自然言語処理（NLP：Natural Language Processing）の実装やっていきます。そのなかでも前処理にフォーカスを当てます。今日のゴールは「文章から動詞だけを抽出する」です。

ascend-beyond.com

2024.03.26

対象読者

前回は40×40のカラー画像を生成しました。しかし、今回は144×144の少し大き目な画像を生成していきましょう！あいかわらず、低品質ですが流れの大枠は正しいはずです。

p.s.もはや抽象画の域ですね。これ（笑）。まぁでも、流れは掴んだんでよしとしましょう！

今回の全コード

かなり、以前までのコードを多く使っているので、かなり解説は割愛させていただきます。というか、だんだん慣れてきましたよね。

import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist
import os
from keras.layers import Dense, Flatten, Reshape, LeakyReLU, Dropout
from keras.models import Sequential
from keras.optimizers import Adam
from keras.layers import BatchNormalization, Activation
from keras.layers import Activation, BatchNormalization
from keras.layers import Conv2D, Conv2DTranspose
import cv2

width = 144
height = 144
channels = 1
shape = (width, height, channels)
noise_dim = 100



def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(256 * 18 * 18, input_dim=noise_dim))
    model.add(Reshape((18, 18, 256)))

    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    
    model.add(Conv2DTranspose(32, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    
    return model


def discriminator_model(shape):
    model = Sequential()

    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(256, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(512, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(1024, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    return model



def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),#0.0001→0.0002,
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))#0.0003→0.0004

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    X_train = load_images("./gray_144_face")
    X_train = X_train / 127.5 - 1.0
    X_train=np.expand_dims(X_train,axis=3)#グレースケールだから
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)


        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)


def save_images(generator, iteration, directory='144x144x_face_gray_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

def load_images(directory):#グレースケール用に変換する
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  
            img = cv2.resize(img, (width, height))
            if len(img.shape) == 3:  # チャンネルが3の場合はグレースケールに変換
                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)



iterations = 20000
batch_size = 128
sample_interval = 1  

train(iterations, batch_size, sample_interval)
generator.save('Face-gene.keras')
discriminator.save('Face-dis.keras')
gan.save('Face-gan.keras')

カラー画像の収集＋前処理

では、早速やっていきましょう。まずは画像収集と前処理です。具体的なコードはこちらでやってみてください。↓

【AI/実践編】画像収集～画像前処理方法【衝撃簡単⑥】

対象読者ここでは、機械学習における画像収集～前処理（サイズ変更・ファイル名変更・グレースケール化）を扱います。このページで紹介する内容は機械学習のサブ的な技術なのでコードの細かな解説などは割愛させていただきます。あくまでも...

ascend-beyond.com

2024.03.07

ここのタスクで私がやったことをまとめます。

1. 独断と偏見から綺麗だと思う女性画像を100枚ずつ計400枚集める
   （有村架純・長澤まさみ・橋本環奈・パクジヒョ）
   集めれるならもっと多い方がいいです。
2. 画像サイズを144×144に変更する
3. ファイル名を変更する

この３ステップをここではやりました。また、先ほど提供した記事でこれらすべてのプログラムコードをのせているので、誰でも簡単にできますよ。

モジュール準備

import matplotlib.pyplot as plt
import numpy as np
from keras.layers import Dense, Flatten,Reshape, LeakyReLU 
from keras.models import Sequential
from keras.optimizers import Adam
import os
from keras.layers import Activation,Dropout,BatchNormalization
from keras.layers import Conv2D
from keras.layers import UpSampling2D
import cv2
#上記↑は『衝撃簡単7』と同じ
from keras.layers import Conv2DTranspose

from keras.layers import Conv2DTranspose
＃Conv2DTransposeは畳み込みの逆操作を行い、入力データをより大きな空間に逆畳み込みするために使用される。
＃通常の畳み込み層は、入力としてデータを受け取り、それをフィルター（カーネル）と畳み込んで、出力を生成します。しかし、Conv2DTransposeは逆の操作を行います。つまり、入力を受け取り、その情報を使用してより大きな出力を生成します。

前回は畳み込み層としてUpsampling2Dを使いました。では、ここで一旦、Conv2DTransposeとUpsampling2Dの違いをまとめておきましょう。

Conv2DTranspose：

• 畳み込みの逆操作を行う
• 入力をより大きな空間に逆畳み込みする
• フィルターを使用して入力に重みを適用し、出力を生成する
• フィルターサイズやストライドなどのパラメータを調整することで、出力のサイズや形状を制御することができる

UpSampling2D:

• 入力データのサイズを拡大する
• 重みはもたない
• 単純に入力の各ピクセルの間に新しいピクセルを挿入し、それらの値を元のピクセルの値と同じにする
• 補間法（nearest neighborやbilinearなど）を使用して、新しいピクセルの値を計算する
• 主なパラメータは拡大する倍率のみ。通常、2の累乗倍率を使用する

要するに、画像生成などのタスクではConv2DTransposeが使用され、データの拡大だけが必要な場合はUpSampling2Dが選択される。

生成画像の型を定義

生成する画像の型を定義します。幅と高さを自分の生成したい大きさに調整します。また、チャンネルはグレースケールなので１にします。

width = 144
height = 144
channels = 1
shape = (width, height, channels)
noise_dim = 100

生成器（ジェネレーター）モデルを定義

def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(256 * 18 * 18, input_dim=noise_dim))
    model.add(Reshape((18, 18, 256)))

    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    
    model.add(Conv2DTranspose(32, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(alpha=0.01))

    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    
    return model

model.add(Dense(256 * 18 * 18, input_dim=noise_dim))
＃18はConv2DTransposeの数、ストライドから導く。
#ストライド２が３あるから、１８ｘ２ｘ２ｘ２＝１４４（画像サイズ）となるようにする。

model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding=’same’))
＃128個のフィルターを使用し、カーネルサイズが3×3で、ストライドが2の畳み込みの逆操作を行う。これにより、18×18の入力が36×36に拡大される。
＃ストライド：畳み込み演算においてフィルター（カーネル）が入力データをどのくらいのステップで移動するかを制御するパラメータ。
＃例：ストライドが1の場合→フィルターは1つのピクセルごとに移動→出力画像は入力と同じサイズ
＃例：ストライドが2の場合→フィルターは2つのピクセルごとに移動→出力は入力の２倍になる
このようにして、畳み込みの逆操作を行い、より大きな出力を生成することができる。

model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding=’same’))
＃stridesを１にしているため、画像サイズはキープされる。

＊以降の解説は前回までで沢山しているので割愛します。

【AI/実践編】DCGANで高画質化【衝撃簡単⑤】

衝撃簡単です。DCGANを使ってフェイク画像を作っていきましょう！ディープフェイクにも使われている技術を誰でも、簡単にできるようにまとめました。AI学習は座学よりも実践あるのみです！DCGANを体験していきましょう！

ascend-beyond.com

2024.03.02

識別器（ディスクリミネーター）を定義

def discriminator_model(shape):
    model = Sequential()

    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))

    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(256, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(512, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Conv2D(1024, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    return model

このdiscriminatorの調整には理論はありません。
『実行しては修正して』を繰り返したら、こうなりました。これが正解ではないので、皆さんも増やしたり、減らしたり、カスタマイズして最適解を導いてみてください。

p.s.以下に私の経験則や一般論を置いておきます。微力ですがカスタマイズで困ったらどうぞ。

【AI/座学】GANパラメーター調整のコツ・極意書

GANモデルは学習が不安定になりがちです。それを見ると、私の心も不安定(なんちゃって)。ここでは、そんな学習も心も不安定になってしまった人に向けての、GANモデルパラメーター調整のコツを紹介します。私の過去からの経験から【これは効果あった】や一般論をまとめています。

ascend-beyond.com

2024.03.02

DCGANモデルの定義とコンパイル

生成器と識別器を結合してDCGANモデルを作成しましょう！

def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

これも今までに何回も登場しました。もはや定型文ですね。

モデルのコンパイル

パラメーターの設定をしていきましょう。

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0007, beta_1=0.5))

こちらも、トライアンドエラーの繰り返しです。強いて言うなら、１つずつ変えてみてください。複数を同時に変更すると、何が影響を与えたか判断できなくなってしまうので。

【AI/座学】GANパラメーター調整のコツ・極意書

GANモデルは学習が不安定になりがちです。それを見ると、私の心も不安定(なんちゃって)。ここでは、そんな学習も心も不安定になってしまった人に向けての、GANモデルパラメーター調整のコツを紹介します。私の過去からの経験から【これは効果あった】や一般論をまとめています。

ascend-beyond.com

2024.03.02

モデルの訓練

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    X_train = load_images("./gray_144_face")
    X_train = X_train / 127.5 - 1.0
    X_train=np.expand_dims(X_train,axis=3)#グレースケールだから
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        batch_images = X_train[idx]
        z = np.random.normal(0, 1, (batch_size, noise_dim))
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images, real_label)
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)


        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)

idx_real = np.random.randint(0, X_train.shape[0] , batch_size)
＃batch_size の数だけデータをランダムに抽出する
＃np.random.randint(a, b, size) 関数は、a 以上 b 未満の範囲からランダムに整数を size 個生成します。

z = np.random.normal(0, 1, (batch_size, noise_dim))
＃引数として、平均（0）、標準偏差（1）、および形状を指定しています。ここで、batch_sizeは生成される行列の行数（サンプル数）、noise_dimは列数（ノイズの次元数）を示しています。

d_loss_real = discriminator.train_on_batch(batch_images_real, real_label)
d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
＃Discriminatorを訓練。本物の画像と偽物の画像をそれぞれ使用して損失を計算。
＃train_on_batch メソッドは、バッチで訓練するために使用されます。このメソッドは、入力データと対応する正解ラベル（または目標値）を受け取り、モデルの重みを更新します。以下に、このメソッドの引数と使い方を説明します。

g_loss = gan.train_on_batch(z, real_label)
＃GANモデルを訓練。GANは、生成された画像を本物と誤認させるように学習します。
＃real_labelは、生成器（Generator）の訓練時に使用される目標値。目標値として本物の画像に対応するラベルが与えられます。

＊他は何回も解説していることなので、割愛します。

【AI/実践編】DCGANで高画質化【衝撃簡単⑤】

衝撃簡単です。DCGANを使ってフェイク画像を作っていきましょう！ディープフェイクにも使われている技術を誰でも、簡単にできるようにまとめました。AI学習は座学よりも実践あるのみです！DCGANを体験していきましょう！

ascend-beyond.com

2024.03.02

画像ロードの関数を定義する

今回は独自の画像データを使うので、モデルに画像を読み込ますためのロード関数が必要になります。ここでは、それを定義していきましょう！

def load_images(directory):#グレースケール用に変換する
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  
            img = cv2.resize(img, (width, height))
            if len(img.shape) == 3:  # チャンネルが3の場合はグレースケールに変換
                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)

これでモデルに独自の画像データを読み込むことができます。

生成画像の保存

画像を保存して目視できるようにしましょう！

def save_images(generator, iteration, directory='144x144x_face_gray_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap='gray')
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

引数のdirectory=を変えないと、以前の保存画像に上書きされてしまうので、これは変えておきましょう！

また、12行目のaxs[row, col].imshow(gene_imgs[cnt, :, :, 0], cmap=’gray’)はグレースケール用に変えています。

p.s.今まで、使ってきたメソッドなので細かい解説は割愛します。

モデルの実行＆保存

バッチサイズを変えると、学習に影響が出ます。それ以外のパラメーターはお好みでどうぞ！

iterations = 20000
batch_size = 128
sample_interval = 100 

train(iterations, batch_size, sample_interval)
generator.save('144Face-gene.keras')
discriminator.save('144Face-dis.keras')
gan.save('144Face-gan.keras')

ファイルの実行

では、実行していきましょう。実行方法は人それぞれですが、私の場合はCMDでファイル名を入力することで実行しています。

ファイル名.py

これで、いい感じの出力がされたら完了です！

学習モデルで１枚ずつ確認してみよう！

今までは、4×4で画像を確認しましたが、サイズを大きく確認したいので１枚で出力されるようにしましょう。

import numpy as np
import matplotlib.pyplot as plt
from keras.models import load_model
import os

noise_dim=100
def generate_and_save_images(generator, noise_dim, save_directory='generated_images', num_images=10):
    if not os.path.exists(save_directory):
        os.makedirs(save_directory)
    
    for i in range(num_images):
        noise = np.random.normal(0, 1, (1, noise_dim))
        generated_image = generator.predict(noise)
        generated_image = 0.5 * generated_image + 0.5  # 画像のスケーリングを元に戻す
        generated_image = np.squeeze(generated_image)  # 不要な次元を削除
        plt.imshow(generated_image, cmap='gray')
        plt.axis('off')
        plt.savefig(f"{save_directory}/generated_image_{i+1}.png")
        plt.close()

# 生成器モデルをロードする
generator = load_model('144Face-gene.keras')

# 10枚の画像を生成して保存する
generate_and_save_images(generator, noise_dim)

これで、大きなサイズで画像を確認できるようになりました。

おわりに

今回は大きなサイズの生成方法を紹介しました。もっと、質を高めたい方は、層を複雑にしたりパラメーターの値をカスタマイズしてみてください。

対象読者

今回は、DCGANでカラー画像を生成していきます！あまり良い結果とは言えませんが、カラー画像自体は生成できているので、まぁよしとしてください💦

今回のゴール設定は『タイプを具現化する』ことです。綺麗だと思う女性の画像を集め、それらに共通する特徴をDCGANで生成してもらいます。これにより、自分のタイプという概念が具現化できます。
ちなみに下が結果です。

女性と思えば女性に見えるレベルの画像ですね（笑）
こんなレベルでもいいよ！と感じたら、読み進めてみてください。

今回のプロセス

では、まずはじめにDCGANでカラー画像生成プロセスを簡単に紹介しておきます。

1. 画像収集
2. 画像加工
3. プログラミング(モデル作成)
   １.モジュール準備
   ２.生成画像の型
   ３.生成器・識別器・GANモデルの構築
   ４.コンパイル
   ５.訓練
   ６.追加の関数とか
   ７.実行
4. モデルの評価・改善
5. 終了

簡単にまとめるとこんな感じです。コードは前回までのを使ったりするので、意外とすんなり終わります。

今回の全コード

半分以上はこれまでの『衝撃簡単シリーズ』で登場したものとなるので、新しいことは意外とありません。
p.s.前回まででの重複箇所の説明は割愛させていただきます

from keras.layers import Input, Dense, Reshape, Flatten, Dropout
from keras.layers import BatchNormalization, Activation, ZeroPadding2D
from keras.layers import LeakyReLU
from keras.layers import UpSampling2D, Conv2D
from keras.models import Sequential, Model
from keras.optimizers import Adam
import matplotlib.pyplot as plt
import os
import cv2
import numpy as np

width = 40
height = 40
channels = 3
shape = (width, height, channels)
noise_dim = 100


def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(10 * 10 * 256, activation="relu", input_dim=noise_dim))
    model.add(Reshape((10, 10, 256)))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())

    model.add(Conv2D(128, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())


    model.add(Conv2D(64, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))

    model.add(Conv2D(3, kernel_size=3, padding="same"))
    model.add(Activation("tanh"))
    return model



def discriminator_model(shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model




def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model


discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))



losses = []
accuracies = []
iteration_checkpoints = []



def train(iterations, batch_size, sample_interval):
    X_train = load_images("./resized_images_40")
    X_train = X_train / 127.5 - 1.0
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx_real = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        idx_fake = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        batch_images_real = X_train[idx_real]
        batch_images_fake = X_train[idx_fake]
        
        # ノイズの生成時に正しい次元数を使用する
        z = np.random.normal(0, 1, (batch_size, noise_dim))  # 修正
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images_real, real_label)  # 修正
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)

        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)


def save_images(generator, iteration, directory='face-gan_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt])
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)


def load_images(directory):
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  # 画像の読み込みが成功した場合のみ処理を続行
            img = cv2.resize(img, (width, height))
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)


iterations = 20000
batch_size = 128
sample_interval = 1  
train(iterations, batch_size, sample_interval)
generator.save('40x40color-Face-gene.keras')
discriminator.save('40x40color-Face-dis.keras')
gan.save('40x40color-Face-gan.keras')

カラー画像の収集＋前処理

では、早速やっていきましょう。まずは画像収集と前処理です。具体的なコードはこちらでやってみてください。↓

【AI/実践編】画像収集～画像前処理方法【衝撃簡単⑥】

対象読者ここでは、機械学習における画像収集～前処理（サイズ変更・ファイル名変更・グレースケール化）を扱います。このページで紹介する内容は機械学習のサブ的な技術なのでコードの細かな解説などは割愛させていただきます。あくまでも...

ascend-beyond.com

2024.03.07

ここのタスクで私がやったことをまとめます。

1. 独断と偏見から綺麗だと思う女性画像を100枚ずつ計400枚集める
   （有村架純・長澤まさみ・橋本環奈・パクジヒョ）
2. 画像サイズを40×40に変更する
3. ファイル名を変更する

この３ステップをここではやりました。また、先ほど提供した記事でこれらすべてのプログラムコードをのせているので、誰でも簡単にできますよ。

モジュール準備

import matplotlib.pyplot as plt
import numpy as np
from keras.layers import Dense, Flatten,Reshape, LeakyReLU 
from keras.models import Sequential
from keras.optimizers import Adam
import os
from keras.layers import Activation,Dropout,BatchNormalization
#上記↑は『衝撃簡単５』と同じ
from keras.layers import Conv2D
from keras.layers import UpSampling2D
import cv2

from keras.layers import Conv2D
＃Conv2Dは入力データ（通常は画像や特徴マップ）に対して畳み込み演算を適用し、新しい特徴マップを生成するライブラリ

from keras.layers import UpSampling2D
＃Upsampling2Dはアップサンプリングプロセスを行うためのライブラリ。
＃Conv2DTransposeを使いたいが、計算量が大きくなってしまうのでやめました。

import cv2
＃cv2は画像処理に使われるライブラリ

生成画像の型を定義

生成する画像の型を定義します。幅と高さを自分の生成したい大きさに調整します。また、チャンネルはカラーなので３にします。

width = 40
height = 40
channels = 3
shape = (width, height, channels)
noise_dim = 100

生成器（ジェネレーター）モデルを定義

def generator_model(noise_dim):
    model = Sequential()
    model.add(Dense(10 * 10 * 256, activation="relu", input_dim=noise_dim))
    model.add(Reshape((10, 10, 256)))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())

    model.add(Conv2D(128, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(UpSampling2D())


    model.add(Conv2D(64, kernel_size=3, padding="same"))
    model.add(Activation("relu"))
    model.add(BatchNormalization(momentum=0.8))

    model.add(Conv2D(3, kernel_size=3, padding="same"))
    model.add(Activation("tanh"))
    return model

model.add(Dense(10 * 10 * 256, activation=”relu”, input_dim=noise_dim))
＃10 * 10 * 256は、出力の次元数を指定しており、10 * 10 * 256個のニューロンを持つ層を定義している。
＃10は、アップサンプリングの数から導く。もし、アップサンプリング数が１つなら20を設定する。。

model.add(Reshape((10, 10, 256)))
＃直前の全結合層からの出力を(10, 10, 256)の形状に変更している。→テンソルを3次元の画像形式に変換できる

model.add(BatchNormalization(momentum=0.8))
＃:学習を安定化し、収束を加速するための手法を用いる
＃momentum=0.8は、モーメンタムの値を指定する。更新において、ほぼ前回の更新の80％を保持して次のステップに反映させる。
＃モーメンタム：収束速度を向上させ、局所的最適解からの脱出を助ける効果。一般的な値は0.9。

model.add(UpSampling2D())
# アップサンプリングは、画像のサイズを拡大する操作であり、ここでは画像を拡大している。デフォルトでは2倍に拡大される。→Dense層の入力はアップサンプリングを考慮する必要がある。

model.add(Conv2D(128, kernel_size=3, padding="same"))
＃Conv2Dは、2次元の畳み込みを行う層。画像データの処理において、畳み込み層はフィルター（カーネル）を用いて画像の特徴を抽出する
＃引数は、畳み込み演算に使用するフィルターの数を指定している。ここでは128個のフィルターを使用している→128個は、モデルが十分な表現力を持ちつつも、計算コストを抑えつつ、多様な特徴を捉えるためのバランスの取れた選択肢
＃kernel_size=3は、畳み込み演算に使用するフィルターのサイズを指定しています。ここでは3×3のフィルター
＃padding="same"は、入力と出力のサイズを同じに保つために、入力画像の周囲にパディングを追加することを指定してる

＊以降は、繰り返しなので割愛

model.add(Activation(“tanh”))
＃tanh関数は、入力が無限に広がる範囲の実数を、 -1 から 1 の範囲にマッピングする関数→生成された画像のピクセル値を調整し、モデルが学習しやすくするために役立つ
＃tanh関数は0 を中心とした対称的な出力を持つ→勾配の効率的な伝播を可能にする

識別器（ディスクリミネーター）を定義

def discriminator_model(shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

＃生成器と逆に、カーネルサイズの増加は、特徴の抽象化の階層を作成する一つの方法。
①最初の層は画像の低レベルの特徴を取得し、
②その後の層はより抽象的な特徴を取得します。
このような階層的な抽象化は、識別器が画像の本質的な特徴を理解するのに役立つ

＊このdiscriminatorコードは今までに何回も使っているので説明は割愛します。

【AI/実践編】DCGANで高画質化【衝撃簡単⑤】

衝撃簡単です。DCGANを使ってフェイク画像を作っていきましょう！ディープフェイクにも使われている技術を誰でも、簡単にできるようにまとめました。AI学習は座学よりも実践あるのみです！DCGANを体験していきましょう！

ascend-beyond.com

2024.03.02

DCGANモデルの定義とコンパイル

生成器と識別器を結合してDCGANモデルを作成しましょう！

def gan_model(generator, discriminator):
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

これも今までに何回も登場しました。もはや定型文ですね。

モデルのコンパイル

パラメーターの設定をしていきましょう。

discriminator = discriminator_model(shape)
discriminator.compile(loss='binary_crossentropy',
                      optimizer=Adam(lr=0.0001, beta_1=0.5),
                      metrics=['accuracy'])

generator = generator_model(noise_dim)
generator.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

discriminator.trainable = False

gan = gan_model(generator, discriminator)
gan.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0003, beta_1=0.5))

こちらは、前回と一緒です。最初に見せたゴール画像よりも良質な画像を生成したい場合はカスタマイズして最適解を導いてみてください。

【AI/実践編】DCGANで高画質化【衝撃簡単⑤】

衝撃簡単です。DCGANを使ってフェイク画像を作っていきましょう！ディープフェイクにも使われている技術を誰でも、簡単にできるようにまとめました。AI学習は座学よりも実践あるのみです！DCGANを体験していきましょう！

ascend-beyond.com

2024.03.02

モデルの訓練

losses = []
accuracies = []
iteration_checkpoints = []

def train(iterations, batch_size, sample_interval):
    X_train = load_images("./resized_images_40")
    X_train = X_train / 127.5 - 1.0
    real_label = np.ones((batch_size, 1))  # 修正
    fake_label = np.zeros((batch_size, 1))  # 修正

    for iteration in range(iterations):
        idx_real = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        idx_fake = np.random.randint(0, X_train.shape[0] - 1, batch_size)  # 修正
        batch_images_real = X_train[idx_real]
        batch_images_fake = X_train[idx_fake]
        
        # ノイズの生成時に正しい次元数を使用する
        z = np.random.normal(0, 1, (batch_size, noise_dim))  # 修正
        gene_imgs = generator.predict(z)

        d_loss_real = discriminator.train_on_batch(batch_images_real, real_label)  # 修正
        d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
        d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)

        z = np.random.normal(0, 1, (batch_size, noise_dim))
        g_loss = gan.train_on_batch(z, real_label)

        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss, g_loss))
            accuracies.append(100.0 * accuracy)
            iteration_checkpoints.append(iteration + 1)

            print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (iteration + 1, d_loss, 100.0 * accuracy, g_loss))
            save_images(generator, iteration + 1)

losses = []、accuracies = []、iteration_checkpoints = []
＃損失、精度、およびイテレーションごとのチェックポイントを格納するためのリストを初期化。

def train(iterations, batch_size, sample_interval):
＃train 関数を定義。この関数は、訓練のメインループ

X_train = load_images("./resized_images_40")
＃画像データを読み込む。load_images 関数は、指定されたディレクトリから画像を読み込む。(以降で定義)

X_train = X_train / 127.5 - 1.0
＃画像のピクセル値を正規化。通常、画像のピクセル値は0から255の範囲だが、これを-1から1の範囲に変換。

real_label = np.ones((batch_size, 1))
fake_label = np.zeros((batch_size, 1))
＃本物の画像と偽物の画像のラベルを定義。

for iteration in range(iterations):
＃指定されたイテレーション数だけ訓練を繰り返す

idx_real = np.random.randint(0, X_train.shape[0] - 1, batch_size)
idx_fake = np.random.randint(0, X_train.shape[0] - 1, batch_size)
＃ランダムなインデックスを生成し、本物の画像と偽物の画像のバッチを選択。
＃np.random.randint(a, b, size) 関数は、a 以上 b 未満の範囲からランダムに整数を size 個生成する。

z = np.random.normal(0, 1, (batch_size, noise_dim))
＃正規分布からランダムなノイズを生成。これはGeneratorの入力として使用。

gene_imgs = generator.predict(z)
＃Generatorを使用して、ノイズから偽の画像を生成。

d_loss_real = discriminator.train_on_batch(batch_images_real, real_label)
d_loss_fake = discriminator.train_on_batch(gene_imgs, fake_label)
＃Discriminatorを訓練。本物の画像と偽物の画像をそれぞれ使用して損失を計算。
＃train_on_batch メソッドは、バッチで訓練するために使用されます。このメソッドは、入力データと対応する正解ラベル（または目標値）を受け取り、モデルの重みを更新します。以下に、このメソッドの引数と使い方を説明します。

d_loss, accuracy = 0.5 * np.add(d_loss_real, d_loss_fake)
＃Discriminatorの損失と精度を計算します。

g_loss = gan.train_on_batch(z, real_label)
＃GANモデルを訓練。GANは、生成された画像を本物と誤認させるように学習します。
＃real_labelは、生成器（Generator）の訓練時に使用される目標値。目標値として本物の画像に対応するラベルが与えられます。

(iteration + 1) % sample_interval == 0
＃サンプル間隔ごとに、損失や精度を保存して結果を表示

save_images(generator, iteration + 1)
＃生成された画像を保存

画像ロードの関数を定義する

今回は独自の画像データを使うので、モデルに画像を読み込ますためのロード関数が必要になります。ここでは、それを定義していきましょう！

def load_images(directory):
    images = []
    for filename in os.listdir(directory):
        img = cv2.imread(os.path.join(directory, filename))
        if img is not None:  # 画像の読み込みが成功した場合のみ処理を続行
            img = cv2.resize(img, (width, height))
            images.append(img)
        else:
            print(f"Warning: Failed to load image {filename}")
    if len(images) == 0:
        print("Error: No images loaded")
        return None
    else:
        return np.array(images)

def load_images(directory):
＃load_images 関数を定義。この関数は、指定されたディレクトリから画像を読み込む

images = []
＃画像を格納するための空のリスト images

for filename in os.listdir(directory):
＃指定されたディレクトリ内のファイルを1つずつ反復処理する。

img = cv2.imread(os.path.join(directory, filename))
＃os.path.join を使用して、ディレクトリとファイル名を組み合わせてファイルのパスを作成
＃cv2.imread を使用して画像を読み込む。

if img is not None:
＃画像が正常に読み込まれたかどうかをチェック

img = cv2.resize(img, (width, height))
＃読み込まれた画像を指定された幅と高さにリサイズ

images.append(img)
＃リサイズされた画像を images リストに追加します。

else:
＃画像が読み込まれなかった場合（img が None の場合）に実行されるブロック

print(f"Warning: Failed to load image {filename}")
＃警告メッセージを出力し、どの画像が読み込めなかったかを表示

if len(images) == 0:
＃読み込まれた画像がない場合をチェックします。

print("Error: No images loaded")
＃エラーメッセージを出力します。

return None
＃画像が読み込まれなかった場合は None を返す

else:
＃それ以外の場合（画像が1つ以上読み込まれた場合）

return np.array(images)
＃images リストをNumPy配列に変換して返す。 NumPy配列は、後続の処理で使用できる形式にデータを整形する。

これでモデルに独自の画像データを読み込むことができます。

生成画像の保存

画像を保存して目視できるようにしましょう！

def save_images(generator, iteration, directory='face-gan_images', image_grid_rows=4, image_grid_columns=4):
    if not os.path.exists(directory):
        os.makedirs(directory)

    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, noise_dim))
    gene_imgs = generator.predict(z)
    gene_imgs = 0.5 * gene_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows, image_grid_columns, figsize=(4, 4), sharey=True, sharex=True)
    cnt = 0
    for row in range(image_grid_rows):
        for col in range(image_grid_columns):
            axs[row, col].imshow(gene_imgs[cnt])
            #カラーなので前回までのgene_imgs[cnt, :, :, 0], cmap='gray'は不要
            axs[row, col].axis('off')
            cnt += 1

    fig.savefig(f"{directory}/iteration_{iteration}.png")
    plt.close(fig)

引数のdirectory=を変えないと、以前の保存画像に上書きされてしまうので、これは変えておきましょう！

モデルの実行＆保存

バッチサイズを変えると、学習に影響が出ます。それ以外のパラメーターはお好みでどうぞ！

iterations = 20000
batch_size = 128
sample_interval = 100 
train(iterations, batch_size, sample_interval)
generator.save('40x40color-Face-gene.keras')
discriminator.save('40x40color-Face-dis.keras')
gan.save('40x40color-Face-gan.keras')

これもよく登場するので割愛します。

【AI/実践編】DCGANで高画質化【衝撃簡単⑤】

衝撃簡単です。DCGANを使ってフェイク画像を作っていきましょう！ディープフェイクにも使われている技術を誰でも、簡単にできるようにまとめました。AI学習は座学よりも実践あるのみです！DCGANを体験していきましょう！

ascend-beyond.com

2024.03.02

ファイルの実行

では、実行していきましょう。実行方法は人それぞれですが、私の場合はCMDでファイル名を入力することで実行しています。

ファイル名.py

これで、いい感じの出力がされたら完了です！

学習モデルで１枚ずつ確認してみよう！

今までは、4×4で画像を確認しましたが、サイズを大きく確認したいので１枚で出力されるようにしましょう。

import numpy as np
import matplotlib.pyplot as plt
from keras.models import load_model
import os
import cv2
noise_dim=100
# 保存したGANモデルの読み込み
generator = load_model('40x40color-Face-gene.keras')

def generate_images(generator, save_directory, num_images=10):
    if not os.path.exists(save_directory):
        os.makedirs(save_directory)

    noise = np.random.normal(0, 1, (num_images, noise_dim))
    generated_images = generator.predict(noise)

    for i in range(num_images):
        img = (generated_images[i] + 1) / 2  # 画像のスケーリングを元に戻す
        plt.imshow(img)
        plt.axis('off')
        plt.savefig(f"{save_directory}/generated_image_{i+1}.png")
        plt.close()

# 画像を保存するディレクトリと生成する画像の枚数を指定して実行
generate_images(generator, "generated_images", num_images=40)

generator = load_model(’40x40color-Face-gene.keras’)
＃括弧内には各自の学習済み生成器ファイル名を入れてください。

generate_images(generator, “generated_images”, num_images=40)
＃手動generated_imagesを作って、それを保存先ディレクトリに指定します。
＃num_images=40は保存する画像数です。

これで、大きなサイズで画像を確認できるようになりました。

おわりに

今回はカラー画像の生成方法を紹介しました。もっと、質を高めたい方は、層を複雑にしたりパラメーターの値をカスタマイズしてみてください。

では、次回はグレースケール画像で、サイズの大きな画像を生成できるようにします。流れは、今までやってきたことと同じなので、ササっとやっていきましょう！

【AI/実装編】サイズの大きな画像を生成【衝撃簡単⑧】

【衝撃簡単】でDCGANモデルで大きな画像を生成していきます。流れはMNISTと同じです。初心者でもできるレベルの学習になので簡単にやっていきましょう。

ascend-beyond.com

2024.03.09

対象読者

ここでは、機械学習における画像収集～前処理（サイズ変更・ファイル名変更・グレースケール化）を扱います。

このページで紹介する内容は機械学習のサブ的な技術なのでコードの細かな解説などは割愛させていただきます。あくまでも道具として使えれば、細かなところは理解してなくてもOKですもんね。

では、前置きはここまでにして早速やっていきましょう！

画像収集(Webスクレイピング）

画像収集にはWebスクレイピングという技術を使います。これを使うことで、膨大な画像データを自動で収集できるようになります。

しかしこの技術の取り扱いは色々と複雑です。禁止されているサイトやページがあったり、個人情報の問題があったりします。なので以下に載せるコードはあくまでも参考としてのみ提供する形をとらせていただきます。

import os
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse, parse_qs
import time

def is_valid_url(url):
    # URLが有効なHTTPまたはHTTPSスキームを持っているかどうかを確認する
    return url.startswith("http://") or url.startswith("https://")

def download_images(query, num_images):
    save_dir = './woman_images'#収集した画像の保存先ディレクトリ
    if not os.path.exists(save_dir):
        os.makedirs(save_dir)
    
    headers = {'User-Agent': 'Mozilla/5.0'}
    downloaded = 0
    while downloaded < num_images:
        # キーワードを含むURLを構築
        url = f"https://www.google.com/search?q={query}&tbm=isch&start={downloaded}"
        # ヘッダーを設定してGoogleにリクエストを送信
        response = requests.get(url, headers=headers)
        # HTMLをパース
        soup = BeautifulSoup(response.text, 'html.parser')
        # 画像のURLを抽出
        image_urls = []
        for img in soup.find_all('img'):
            image_url = img.get('src')
            if image_url and is_valid_url(image_url):
                image_urls.append(image_url)
        # 画像をダウンロード
        for i, image_url in enumerate(image_urls):
            try:
                if downloaded >= num_images:
                    break
                image_data = requests.get(image_url).content
                with open(f'{save_dir}/{query}_{downloaded}.jpg', 'wb') as f:
                    f.write(image_data)
                print(f"Downloaded image {downloaded+1}/{num_images}")
                downloaded += 1
            except Exception as e:
                print(f"Error downloading image {downloaded+1}: {e}")
        time.sleep(1)  # Googleへの負荷を軽減するために1秒待つ

# 使用例
query = "ジヒョ　高画質"  # 検索キーワード
num_images = 100  # ダウンロードする画像の数
download_images(query, num_images)

12行目: 画像の保存先ディレクトリを指定

20行目: 参考用としてGoogleにしましたが、規約などを確認し自己責任で実行してください。

43行目: サーバーの負荷を考えるともっと大きな数字でもいいかも

46行目: 人名(スペース)高画質とする→不純な画像が入ることを極力減らせる

47行目: 自分が欲しい枚数を指定してください。

これらの行をカスタマイズしPythonファイルを実行すれば画像の自動収集ができます。しかし、実行する前には必ず以下の免責事項を一読してください。

画像のサイズ変更

PythonのPILライブラリは画像の読み込み、変換、保存などのさまざまな操作を行うことができます。これを使うことで、画像のサイズ変更を自動化できるようになります。

from PIL import Image
import os

def resize_images(input_folder, output_folder, target_size):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    for filename in os.listdir(input_folder):
        try:
            # 画像を開く
            img_path = os.path.join(input_folder, filename)
            img = Image.open(img_path)
            # 画像を指定されたサイズにリサイズする
            resized_img = img.resize(target_size)
            # リサイズした画像を保存する
            output_path = os.path.join(output_folder, filename)
            resized_img.save(output_path)
            print(f"Resized image: {output_path}")
        except Exception as e:
            print(f"Error resizing image {filename}: {e}")

# 使用例
input_folder = './woman_images'  # 元の画像が保存されているフォルダ
output_folder = './resized_images_144'    # リサイズされた画像を保存するフォルダ
target_size=(144,144)# 目標の画像サイズ (幅, 高さ)
resize_images(input_folder, output_folder, target_size)

23~26行目はご自分の環境に合わせてカスタマイズしてください。あとは、変更不要です。

ファイル名変更

これは、次のグレースケール化の前準備となります。cv2ライブラリを使うときに、ファイル名が日本語などの特殊文字だとエラーが起きます。それを防ぐためにファイル名をランダムな数字に変更していきます。

p.s.カラー画像で学習する場合には、このタスクと次のタスクは不要です。

import os
import random
import string

# ディレクトリのパスを指定
directory = './resized_images_144'

# ディレクトリ内のファイルを取得
files = os.listdir(directory)

# ファイルごとにループ
for filename in files:
    # 拡張子を取得
    _, ext = os.path.splitext(filename)
    
    # 新しいファイル名を生成
    new_filename = ''.join(random.choices(string.digits, k=8)) + ext
    
    # 新しいファイル名のパスを作成
    new_filepath = os.path.join(directory, new_filename)
    
    # ファイル名を変更
    os.rename(os.path.join(directory, filename), new_filepath)

６行目を自分の環境にあうように変えてください。あとは変更不要です。

グレースケール化

cv2にライブラリを使ってグレースケール化していきます。ただしファイル名が日本語などの特殊文字だとエラーが起きます。しっかりと、前のタスクでファイル名を適切な形にしておいてくださいっ。

import cv2
import os

# 入力画像が保存されているフォルダパス
input_folder = 'resized_images_144'

# 出力フォルダパス
output_folder = 'gray_144_face'

# 入力フォルダ内のすべての画像ファイルを処理
for filename in os.listdir(input_folder):
    # 画像ファイルのパスを取得
    input_path = os.path.join(input_folder, filename)
    
    # 画像をグレースケールで読み込む
    img = cv2.imread(input_path)
    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 出力ファイルのパスを指定
    output_path = os.path.join(output_folder, filename)
    
    # グレースケール画像を保存
    cv2.imwrite(output_path, gray_img)

print("変換が完了しました。")

５、８行目を自分用にカスタマイズすれば、他は変更不要です。

おわりに

今回は、画像収集と画像処理方法を紹介しました。これらの技術は当サイトのAI学習タスクで頻繁に使います。

これらの技術を用いた機械学習タスクの実践編を置いておく↓ので、実践を試したい方は自由に利用してください。(只今調整中)

対象読者

今回は損失関数についてやっていきます。対象者はAI構築を目標としている方です。そのため理論の深堀はしません。なぜなら、深いところまで理解しようとすると、いつまでも実践に進めないからです。

そのためここでは、実践に必要最低限の知識のみを解説し、パパっと座学を終わらせてすぐに実践をやれる環境を提供しています。

座学をおえたら、下の記事から実践も試してみてください。

【AI/実践編】MNISTでAIを体験【衝撃簡単①】

AIの深い原理が分からなくても作れます！MNISTを使ったとっても簡単な実装をやっていきます。AIの概要は学んだけど何から作ればいいんだろう。という悩みをお持ちのあなたにピッタリのタスクです。また、始めたばかりで100％の理解を求める必要はありません。50%理解できたらいいや程度の軽い気持ちで学習を進めましょう。その方が挫折することなく長期間続けられ、結果的にいつか50%の理解が90%以上の理解になる時がきます。

ascend-beyond.com

2024.02.24

【衝撃簡単！】誰でも一流AIエンジニアになるAI勉強法

複雑な仕組みや数学が難しくて全然AIの勉強が進まない。しかし、それも今日までにしましょう。あなたがもし、複雑な概念理解ができなくても、学びたいという気持ちがあるのなら王道ではなく邪道の勉強プロセスを歩みましょう。王道の勉強プロセスは数学ができる人向けに作られたプロセスです。数学が苦手な人にはそれ用の勉強プロセスを歩むべきなのです。

ascend-beyond.com

2024.02.20

カテゴリカルクロスエントロピー

カテゴリカルクロスエントロピーのポイント

• 多クラス交差エントロピー損失のこと
• 名前通り、多クラス分類問題に使用される
• 機械学習における損失関数の一つ
• 分類問題でモデルの出力と実際のクラスの間の距離を測るために使用
• 出力される確率分布と実際のクラスの間の差異を測る
• 予測が正しいクラスに近いほど→損失が低くなる
• 機械学習などのモデルの学習において、分類問題で使う
• ソフトマックス関数と組み合わせて使われる
• 損失が低いほど→モデルの予測が正確
• 微分可能な関数であり、勾配降下法などの最適化アルゴリズムで使用できます。
• クラスの数が多い場合には、計算コストが増加する

おまけ：カテゴリカルクロスエントロピーの数式

$$\text{Categorical Cross-Entropy Loss} = -\sum_{i} y_i \log(p_i)$$

式の解釈：yiは実際のクラス i のラベル（正解ラベル）であり、piはモデルがクラス i に割り当てた確率です。

最短コースでわかるPyTorch&深層学習(ディープラーニング)プログラミング ひと目でわかる最短コースマップ付き／赤石雅典【3000円以上送料無料】 価格：4,070円（税込、送料無料) (2024/3/4時点)

二項交差エントロピー損失(Binary Cross-Entropy Loss)

バリナリクロスエントロピーのポイント

• 2つのクラスの分類問題に適した損失関数
• バイナリクロスエントロピーの呼び名で知られる
• ２値分類に適する
• モデルが出力した確率分布と実際のクラスの間の距離を測ります。
• 損失が低いほど→モデルの予測が正確
• モデルの出力が0から1の確率であることを前提としています。
• 微分可能な関数であり、勾配降下法などの最適化アルゴリズムで使用できます
• サンプル数が少ない場合やクラス間の分布が不均衡な場合、過学習のリスクがあります。

おまけ：バイナリクロスエントロピーの数式

$$\text{Binary Cross-Entropy Loss} = -\frac{1}{N} \sum_{i=1}^{N} [y_i \log(p_i) + (1 – y_i) \log(1 – p_i)]$$

式の解釈：ここで、N はサンプルの数、yi​ は実際のクラスラベル（0または1）、pi​ はモデルがクラス1に属する確率を表します。

【POD】MNISTから始める深層学習 -PyTorch- （技術の泉シリーズ（NextPublishing）） [ kobot ] 価格：2,200円（税込、送料無料) (2024/3/4時点)

平均二乗誤差(Mean Squared Error, MSE)

平均二乗誤差（Mean Squared Error, MSE）のポイント

• 平均二乗誤差（Mean Squared Error, MSE）は、損失関数の一つ
• 平均二乗誤差は、モデルの予測値と実際の値との差の二乗の平均を計算する
• 回帰問題に使用
• 損失が低いほど→モデルの予測が正確
• 外れ値に敏感で大きな損失を与える傾向がある
  外れ値：ハズレ値は異常値とも呼ばれ、データのパターンや傾向から大きく外れている値を持つデータポイントのこと
• 外れ値の影響を軽減するためには→ロバスト性が必要
  ロバスト：外れ値やノイズの影響を受けにくいこと
• 微分可能な関数であり、勾配降下法などの最適化アルゴリズムで使用できます。
• 分類問題とは異なり、クラスの不均衡などの課題に対処する機能がない

おまけ：平均二乗誤差の数式

$$\text{MSE} = \frac{1}{N} \sum_{i=1}^{N} (y_i – \hat{y}_i)^2$$

式の解釈：ここで、N はサンプルの数、yi​ は実際の値、y^​i​ はモデルの予測値を表します。

図解即戦力　機械学習&ディープラーニングのしくみと技術がこれ1冊でしっかりわかる教科書 [ 株式会社アイデミー 山口達輝 ] 価格：2,178円（税込、送料無料) (2024/3/4時点)

まとめ（それぞれの使い分け）

• カテゴリカルクロスエントロピー:
  • 多クラス分類問題に使用されます。
  • 出力が複数のクラスの確率分布で表される場合に適しています。
  • クラスの数が2つ以上の場合に適用されます。
• 二項交差エントロピー損失:
  • 2クラス分類問題に使用されます。
  • 出力が2つのクラスの確率で表される場合に適しています。
  • クラスの数が2つの場合に適用されます。
• 平均二乗誤差:
  • 回帰問題に使用されます。
  • 出力が連続値であり、目標値との差を考慮する必要がある場合に適しています。
  • 出力が確率分布ではなく、実数値である場合に適用されます。

おわりに

今回は、機械学習・ニューラルネットワークを構築する際に覚えておくべき損失関数を紹介しました。大体この３つが使われます。

では、座学はここまでにして実践をどんどん積んでいきましょう！

p.s.もし、やるべきことが決まっていない方はこちら↓をご自由に使ってみてください

【AI/実践編】MNISTでAIを体験【衝撃簡単①】

AIの深い原理が分からなくても作れます！MNISTを使ったとっても簡単な実装をやっていきます。AIの概要は学んだけど何から作ればいいんだろう。という悩みをお持ちのあなたにピッタリのタスクです。また、始めたばかりで100％の理解を求める必要はありません。50%理解できたらいいや程度の軽い気持ちで学習を進めましょう。その方が挫折することなく長期間続けられ、結果的にいつか50%の理解が90%以上の理解になる時がきます。

ascend-beyond.com

2024.02.24

対象読者

GANモデルは学習が不安定になりがちです。それを見ると、私の心も不安定(なんちゃって)。

ここでは、そんな学習も心も不安定になってしまった人に向けての、GANモデルパラメーター調整のコツを紹介します。

また、ここでは数式などの複雑な概念理解は問いません。必要な能力は数学的思考よりも論理的思考です。

ここでしっかり学習してパズル間隔でパラメーターを調整できるようになりましょう！そして、一歩ずつ一流のAIエンジニアに近づきましょう！

判断基準となる前提知識

まずは、前提知識をつけましょう。前提知識があると….

• パラメーターの調整が運任せにならない
• 損失などの評価結果を見たら推測が立てられる
• 推理が正しかった時のヤバいくらいのアドレナリンが得られる（笑）

こんな風に、前提知識を持つだけで、一流のAIエンジニアに大きく近づけるのです。やるんだったら、一流を目指しましょう！超越しちゃいましょう！

知識：バッチサイズの大小調整

大きくする場合のメリット・デメリット:

• 計算効率の向上: 大きなバッチサイズを使用すると、GPUやCPUなどのリソースを効率的に使用できます。これにより、トレーニング時間が短縮されます。
• モデルの安定性: 大きなバッチサイズを使用すると、勾配の推定がより安定し、モデルの訓練が安定化します。
• 汎化性能の向上: 大きなバッチサイズを使用すると、モデルがより多くのデータで訓練されるため、汎化性能が向上する可能性があります。
• メモリ消費量の増加: 大きなバッチサイズを使用すると、メモリの消費量が増加し、メモリ不足になる可能性があります。
• 局所解への収束: 大きなバッチサイズを使用すると、モデルが局所解に収束しやすくなる局所最適化に陥る。これにより、多様性のある解を見つけにくくなる可能性があります。

小さくする場合のメリット・デメリット:

• メモリ消費量の削減: 小さなバッチサイズを使用すると、メモリの消費量が削減されます。
• 多様な勾配: 小さなバッチサイズを使用すると、より多様な勾配が得られ、モデルがより多様な方向に学習できます。つまり局所最適化を防ぎやすくなります。
• 計算効率の低下: 小さなバッチサイズを使用すると、計算効率が低下し、トレーニング時間が長くなる可能性があります。
• モデルの不安定性: 小さなバッチサイズを使用すると、勾配の推定が不安定になり、モデルの訓練が不安定になる可能性があります。つまり、学習が収束しにくくなります。

知識：学習率の大小調整

大きい場合のメリット・デメリット:

• 高速な収束: 学習率が大きいと、各更新ステップでのパラメータの変化量が大きくなり、収束が速くなる場合があります。
• 局所最適解の脱出: 大きな学習率を使用すると、局所最適解に収束するのを防ぐために大域的な最適解に向かう可能性が高まります。
• 発散のリスク: 学習率が大きすぎると、更新ステップごとにパラメータが大きく変化しすぎて、最適解を飛び越えてしまう可能性がある。
• 安定性の低下: 大きな学習率を使用すると、安定性が低下し、学習が不安定になる場合があります。つまり、収束しにくくなります。

小さい場合のメリット・デメリット：

• 安定した学習: 学習率が小さいと、更新ステップごとにパラメータの変化量が小さくなり、学習が安定しやすくなります。
• 局所最適解への収束: 小さな学習率を使用すると、局所最適化に陥ってしまいます。
• 収束が遅い: 学習率が小さいと、収束するまでに多くのエポックが必要になり、学習時間が長くなる可能性があります。

知識：ドロップアウトの大小調整

大きくする(追加・増加・割合)場合のメリット・デメリット

• モデルの正則化: 大きなドロップアウト率を使用すると、モデルがより多くのノードをランダムに無効にするため、モデルの正則化が向上し、過学習を減らす効果があります。
• 汎化性能の向上: 大きなドロップアウト率を使用すると、モデルがより汎化され、新しいデータに対する性能が向上する可能性があります。

• 表現力の低下: 大きなドロップアウト率を使用すると、モデルが表現力を失い、モデルの性能が低下する可能性があります。表現力を失うと、より単純な特徴に依存するようになります。また、表現力を失うとは、学習することができる表現空間が制限されることを意味します。
• 学習の収束が遅くなる: 大きなドロップアウト率を使用すると、モデルが収束するのにより多くのエポックが必要になる場合があり、学習時間が長くなる可能性があります。

小さく(削除・減らす・割合)する場合のメリット・デメリット：

• 表現力の向上: ドロップアウトをなくすか、減らすと、モデルの表現力が向上し、より複雑なパターンを捉えることができます。
• 学習の収束が早くなる: ドロップアウトをなくすか、減らすと、モデルの学習が収束するのに必要なエポック数が減少し、トレーニング時間が短縮される可能性があります。
• 過学習のリスク: ドロップアウトをなくすか、減らすと、モデルが訓練データに過剰に適合しやすくなり、過学習のリスクが高まります。

知識：識別器と生成器の強弱調整

GANの理想形は識別器と生成器の強さが五分五分になることです。もしバランスが取れないと以下のようになります。

• 識別器が強すぎると、ほとんどが偽とはじかれて学習の方向性が分からなくなる。
• 識別器が弱すぎると、偽画像の改善点がわからないので低レベルな品質が続く。

特に多いのは識別器が強くなるケースです。というのも、識別器は判定するだけですが、生成器は０から画像を作り出すという労力の大きい仕事をしなければなりません。そのため、識別器は生成器よりも早く学習を収束させてしまい、GANのバランスが崩れるのです。

つまり、私たちがやるべいことは
『生成器が追いつける範囲で識別器を強化しつつも、高品質のために過度な弱体化を避ける』というとても絶妙なバランスを見つけなくてはならないのです。

仮説を立てる練習！

では、前提知識はここまでにして、その知識の活用練習をしていきましょう。

例題：学習を開始して以下のような出力がされました。あなたなら、どのように見ますか？今までの知識を使って、何かしらの仮説を立てていきましょう。仮説は何個でも挙げられます。その仮説を１つずつ潰していくことが、学習の最適化に繋がります。

p.s.紹介した仮説と違うからと言って皆さんの仮説が間違っているわけではありません。いくらでも仮説は立てられますのでね。

例題1

これは失敗する時によく見るパターンですね。

50 [D loss: 0.000624, acc.: 100.00%] [G loss: 0.007994]
1000 [D loss: 0.004652, acc.: 99.69%] [G loss: 0.008186]
2150 [D loss: 0.002862, acc.: 100.00%] [G loss: 0.000937]
3200 [D loss: 0.006426, acc.: 99.20%] [G loss: 0.005835]
4300 [D loss: 0.000406, acc.: 100.00%] [G loss: 0.007646]
5350 [D loss: 0.000592, acc.: 100.00%] [G loss: 0.000230]

仮説：
・正解率をみると、100%付近にずっといる→識別器が強い立ち位置をキープ
・G lossがずっと0.00~という小さな値→識別器の損失にG lossが引っ張られている（G lossは識別器と生成器を合わせた損失なので、識別器の損失が極端に低い場合はそれに引っ張られて生成器の損失が無視されてしまいます。その結果、0.00~という低い損失を維持し続けているのです。

この２点から識別器が強すぎる可能性があると推理→識別器を弱めてみよう！

p.s.弱め方は以下で解説します。

例題２

50 [D loss: 0.000624, acc.: 100.00%] [G loss: 0.007994]
100 [D loss: 0.694652, acc.: 54.69%] [G loss: 1.168186]
150 [D loss: 0.732862, acc.: 40.23%] [G loss: 0.726937]
200 [D loss: 0.756426, acc.: 33.20%] [G loss: 0.835835]
300 [D loss: 0.711406, acc.: 36.33%] [G loss: 0.747646]
350 [D loss: 0.703592, acc.: 44.53%] [G loss: 0.748230]
～
700 [D loss: 0.695925, acc.: 49.61%] [G loss: 0.702438]
800 [D loss: 0.696105, acc.: 50.00%] [G loss: 0.697281]
900 [D loss: 0.688253, acc.: 56.25%] [G loss: 0.704283]
1000 [D loss: 0.687551, acc.: 56.25%] [G loss: 0.706025]
1350 [D loss: 0.697760, acc.: 48.44%] [G loss: 0.717108]
1400 [D loss: 0.686100, acc.: 53.91%] [G loss: 0.708159]
2000 [D loss: 0.659652, acc.: 60.16%] [G loss: 0.790444]
3000 [D loss: 0.645585, acc.: 62.50%] [G loss: 0.880491]
4000 [D loss: 0.553337, acc.: 74.22%] [G loss: 1.089478]
～
14000 [D loss: 0.467627, acc.: 78.12%] [G loss: 1.328423]
15000 [D loss: 0.543287, acc.: 69.92%] [G loss: 1.445801]
19000 [D loss: 0.486697, acc.: 75.00%] [G loss: 1.706172]

・最初の100%→識別が優位（始めは識別器が優位になりがち）
・それ以降は50%前後→生成器と識別器がいい感じで競い合っている
・4000イテレーションから70%になった→識別器が少しだけ優位になった

ここから、この出力結果はいい感じの学習プロセスを歩んでいると分かる。

p.s.一般的に最初の方は識別器が優勢になりやすいので、最初の100％はあまり考える必要がないかもしれません。

おまけ：識別器を弱めるには？

上述のように、識別器を弱める機会は往々にしてあります。なので、ここでは識別器を弱体化させる手段を４つほど紹介していきます。

p.s.弱体化は品質にも関わることなので、過度な弱体化は避けましょう。

バッチ正則化の排除

バッチ正則化のメリットは、収束速度を上げることです。そのため、識別器にこれを適用してしまうと、生成器の学習が識別器に追いつけなくなる可能性が上がります。そしてそれは、低品質な画像に繋がります。

そのため、もし早い段階から正解率が100%を記録し続けたら識別器のバッチ正則化層を取り除いてみましょう。

ドロップアウトを追加

ドロップアウトは過学習の抑制や学習時間が長くなるという特徴があります。つまり、あえて識別器の学習時間を延ばすことで、識別器の優位性を減少させることができるのです。

そのため、識別器の優位性を減らす手段としてドロップアウトを追加したりすることは有効な手となります。

ただし、ドロップアウトを大きくし過ぎると単調な画像しか生成できなくなるので、バランスを考えながらやりましょう。

学習率を小さく

学習率を小さくすることで、収束に時間をかけることができます。そのため、識別器は生成器よりも小さな学習率を設定しましょう。そして、生成器にはより大きな学習率を設定して識別器に対抗できるようにしましょう。

ただ、生成器の学習速度を速めすぎると優先しすぎると、収束しなくなるというリスクもあります。

生成器ネットワークの強化

生成器のネットワークを強化することで、間接的に識別器を弱めることができます。

生成器を強化するには・・

• ネットワークの複雑さの増加: 生成器のネットワークをより深く、より広くすることで、モデルの表現力を向上させることができます。新しい層を追加したり、各層のユニット数を増やしたりすることで、生成器がより複雑なデータ分布を学習する能力が向上します。
• 新しい層の追加: 生成器のネットワークに新しい層を追加することで、モデルの表現力を向上させることができます。たとえば、畳み込み層や転置畳み込み層など、新しいタイプの層を追加して、モデルの表現力を向上させることができます。
• 正則化の強化: 生成器のネットワークに正則化手法を追加することで、過学習を防ぎ、モデルの汎化能力を向上させることができます。例えば、ドロップアウトやバッチ正規化などの手法を使用して、モデルを安定化させることができます。
• 特徴量の追加: 生成器の入力に新しい特徴量を追加することで、モデルの表現力を向上させることができます。入力データに含まれる情報量を増やすことで、モデルがより複雑なデータ分布を学習することができます。

これらの方法を組み合わせることで、生成器がリアルな偽物画像を生成できるようになります。そして、それは識別器を騙すことにも繋がり生成器の優位性を確保できるようになります。

おわりに

今回はパラメーターの座学を行いました。しかし、なによりパラメーターを上手く調整するのは知識よりも経験則です。そのため、Ascend-beyond式にのっとってこれからも、実践重視でやっていきましょう。

座学はあくまでも、サブ的な扱いで実践を重視する。それがAI学習の基本でありAscend-beyond式AI学習法です。

【AI/実践編】MNISTでAIを体験【衝撃簡単①】

AIの深い原理が分からなくても作れます！MNISTを使ったとっても簡単な実装をやっていきます。AIの概要は学んだけど何から作ればいいんだろう。という悩みをお持ちのあなたにピッタリのタスクです。また、始めたばかりで100％の理解を求める必要はありません。50%理解できたらいいや程度の軽い気持ちで学習を進めましょう。その方が挫折することなく長期間続けられ、結果的にいつか50%の理解が90%以上の理解になる時がきます。

ascend-beyond.com

2024.02.24

【AI/実践編】生成AI-GANを実装【衝撃簡単④】

AIの深い原理が分からなくても作れます！今日はそんなAI技術を実践していきます。GANと呼ばれる画像生成AIを構築していきます。深い原理や、複雑な数学的思考は必要ありません。いまや、AIはパズル間隔でできる技術になっています。原理が分からなくても、実践でどんどん原理なんて補ってやりましょう！

ascend-beyond.com

2024.02.27