Let your images lie in /pathtoimages/unchanged/.

Create the folder /pathtoimages/changed/

SetDirectory["/pathtoimages/unchanged/"];
names = FileBaseName /@ FileNames["*.png"];

I'm using the extension png in my example, as I have a bunch of png images somewhere on my machine. If you have photos, they're most likely with the extension jpg - adjust accordingly.

Do[im = Import[name <> ".png"]; 
 Export["../changed/" <> name <> "_blackwhite.png", Binarize[im]];
 Export["../changed/" <> name <> "_grayscale.png", ColorConvert[im, "Grayscale"]];
 , {name, names}]

It's quite slow - took about 30 seconds for 11 files with a total size of 3MB

There is no documented way to do this within Mathematica, as you can check yourself in the documentation.

There are free tools like optipng and pngcrush that you can use to recompress an existing PNG file to a smaller size. You can call these directly from within Mathematica using RunProcess and related functions.

To export to text you need b in string form. Converting to PNG and Base64 works.

a = Import["ExampleData/rose.gif"];
b = ExportString[a, {"Base64", "PNG"}]
c = ImportString[b, {"Base64", "PNG"}]
Export["D:/flower.txt", b, "String"];
b1 = Import["D:/flower.txt", "String"];
ByteCount /@ {b, b1}
b == b1

{41016, 41016}
True

Happy New Year!

Import[FileNameJoin[{"Path", "To", "Directory", "*.jpeg"}], "JPEG"] is undocumented but will work (for now, subject to change).

I recommend perhaps FileSystemMap for this task. Simply Import[#, "JPEG"] & /@ FileNames["/Path/To/Directory/*.jpeg"] will work just fine as well.

Make your filenames unambiguously parsable, e.g. by consistently using some delimeters like underscores or something. A typical file name can look like "Electric_B_3.png". EDIT If you have no control over the file names, use string patterns as described by other answers, but in the long-term you may benefit from creating your own robust naming scheme END EDIT

Then write a function that would parse a single file name, something like:

fileNameParse[fname_String, delim_String: "_"] :=
   StringSplit[FileBaseName[fname], delim]

Then, Map it on FileNames["*.png", {your-dir}].

Finally, apply your importOne on the level one:

importOne@@@Map[fileNameParse, FileNames["*.png", {your-dir}]]

Since you have the result of Map available as well, you can regroup them any way you want. You can, for example, Map a function {#, importOne@@#}&, rather than just using importOne@@@.... Then, you could use GatherBy or any other means to regroup and collect your images according to the parts of their filenames.

EDIT

Here is a self-contained example ( I use text files, but this doesn't matter):

ClearAll[fileNameParse, fileNameMake, importOne, $dir];
fileNameParse[fname_String, delim_String: "_"] :=
    StringSplit[FileBaseName[fname], delim];

fileNameMake[pieces_List, delim_String: "_", ext_String: ".txt"] :=
    StringJoin[Append[Riffle[pieces, "_"], ".txt"]];

importOne[set_, cat_, num_, dir_: $dir] :=
    Import[FileNameJoin[{dir, fileNameMake[{set, cat, num}]}]];

We now create a temporary directory:

$dir = FileNameJoin[{$TemporaryDirectory, "ImportTest"}];
If[! FileExistsQ[$dir], CreateDirectory[$dir]];

Create sample files:

MapIndexed[
   Export[#, "Test" <> ToString[#2], "Text"] &,
   Flatten[
     Outer[
       FileNameJoin[{$dir, fileNameMake[{##}]}] &,
       {"Electric"}, {"A", "B", "C"}, {"1", "2", "3"}
     ]]];

import them:

imported = Map[{#, importOne @@ #} &,  fileNameParse /@ FileNames["*.txt", {$dir}]]

(* 
  ==>

     {{{"Electric", "A", "1"},  "Test{1}"}, {{"Electric", "A", "2"}, "Test{2}"}, 
      {{"Electric", "A", "3"},  "Test{3}"}, {{"Electric", "B", "1"}, "Test{4}"}, 
      {{"Electric", "B", "2"},  "Test{5}"}, {{"Electric", "B", "3"},  "Test{6}"}, 
      {{"Electric", "C", "1"},  "Test{7}"}, {{"Electric", "C", "2"},  "Test{8}"}, 
      {{"Electric", "C", "3"}, "Test{9}"}
      }
*)

You can now, for example, group them according to whatever parts of their file names you wish:

GatherBy[imported , #[[1, 2]] &][[1]]

(* 
 ==>

{{{"Electric", "A", "1"}, "Test{1}"}, {{"Electric", "A", "2"}, "Test{2}"}, 
   {{"Electric", "A", "3"}, "Test{3}"}}

*)

As Simon already pointed out, don't use a raster-format for a vector-graphics. Instead, export you plot to e.g. a scalable vector graphics:

graph = GraphPlot[ExampleData[{"Matrix", "HB/can_292"}, "Matrix"]];
Export["graph.svg", graph]

The advantage is, that in such an image, you can still adjust and change lines, polygons and colors. And finally, you can export it to an image of arbitrary quality easily.

And remember, for Plots which contain lines, polygons, ... everything with sharp edges you should never use jpg. General speaking, this is a format for photographs only since its compression is made for reducing filesize in natural images. In those images you don't recognize the compression, in images with text, lines and polygons you certainly will notice the artefacts. Use png if possible. Take your browser and zoom into the above image.

Here a two ways to save all your notebook graphics to PNG files :

1. Web page with PNG Graphics

This is the quick and indirect way to do that and is actually what you tried. But as you said, by default the exported graphics in the folders are in the GIF format. To Export a notebook to a web page with all the graphics in PNG, this seems to work:

Export["test.html", EvaluationNotebook[], "GraphicsOutput" -> "PNG"]

You have to type the command directly in the notebook containing the pictures (for example at the end of it).

Or if you prefer to run the command from another notebook:

nb = NotebookOpen["your_notebook_file_path"];
Export["test.html", nb, "GraphicsOutput" -> "PNG"]
NotebookClose[nb];

2. Programmatically Export only the graphics

Though I am not really familiar with low level notebook programming, here is some more direct approach I've succeeded to get. It allows to search for all the (2D) graphics in a given notebook and export them to whatever format.

First, as previously, choose the notebook you want:

nb = NotebookOpen["your_notebook_file_path", Visible -> True];

or we can here instead use this demo notebook (from the documentation):

nb = CreateWindow[
   DocumentNotebook[{CellGroup[{TextCell["Text Group", "Section"], 
       TextCell["Mary had a little lamb.", "Text"], 
       TextCell["Its fleece was white as snow.", "Text"]}], 
     CellGroup[{TextCell["Graphics Group", "Section"], 
       ExpressionCell[ Plot[Exp[-x^2], {x, -3, 3}], "Output"], 
       ExpressionCell[ Plot[-x^2, {x, -3, 3}], "Output"]}]}]];

and then run:

SelectionMove[nb, Before, Notebook]; SelectionMove[nb, Next, Cell];
i = 0;
While[(nr = NotebookRead[nb]) =!= {}, 
 If[MatchQ[nr, Cell[BoxData[GraphicsBox[__]], __]],
  i++; Export["test_" <> ToString[i] <> ".png", nr]; Print[i]]; 
 SelectionMove[nb, Next, Cell]]
NotebookClose[nb];

which will print the number of exported graphics as it runs. In your case (1000 graphics) that might be useful to monitor the process. It is easy to adapt the code anyway, in particular to modify the file names (here "test_") and the format of exported graphics (here ".png"). That's it.

Remark: For those which are more familiar with low level notebook programming, i've not been able to use the command SelectionMove[notebook, Next, Graphics] to select iteratively the graphics ... If someone could explain how it exactly works ?